本系列文章只为记忆使用,非一步一步学习资料。
1.下面就是一个基本类的形式。定义了属性greeting,定义方法greet()
class Greeter {
greeting: string;
constructor(message: string) {//构造方法
this.greeting = message;//使用了this
}
greet() {//一般方法
return "Hello, " + this.greeting;
}
}
let greeter = new Greeter("world");
2.继承,和C#等语言差不多
class Animal {
name:string;
constructor(theName: string) { this.name = theName; }
move(distanceInMeters: number = 0) {
console.log(`${this.name} moved ${distanceInMeters}m.`);
}
}
class Snake extends Animal {//关键字extends是继承
constructor(name: string) { super(name); }//调用父类的构造方法
move(distanceInMeters = 5) {//重写父类的方法
console.log("Slithering...");
super.move(distanceInMeters);
}
}
class Horse extends Animal {
constructor(name: string) { super(name); }
move(distanceInMeters = 45) {
console.log("Galloping...");
super.move(distanceInMeters);
}
}
let sam = new Snake("Sammy the Python");
let tom: Animal = new Horse("Tommy the Palomino");
sam.move();
tom.move(34);
3.readonly修饰符
你可以使用readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。
class Octopus {
readonly name: string;
readonly numberOfLegs: number = 8;//定义时初始化
constructor (theName: string) {
this.name = theName;//构造方法中初始化
}
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // error! name is readonly.
4.参数属性可以方便地让我们在一个地方定义并初始化一个成员。
这个和别的语言时候区别的,在构造方法中,在定义参数的时候,加上private,protected,public等访问限制符号就可以定义一个属性,这个的确是比较方便的。显得有点懒了:),不过的确好
class Animal {
constructor(private name: string) { }//构造方法中使用了访问修饰符,就相当于定义了一个属性了,调用构造方法,就给name赋值了
move(distanceInMeters: number) {//在一般方法中,不能使用访问修饰符来添加属性的
console.log(`${this.name} moved ${distanceInMeters}m.`);
}
}
let a=new Animal("test");//这样就给name赋值了
console.log(a.name);//可以打印出test了
5.存取器,get,set这个是比较方便的检查数据的方式,优美的语法糖(注意格式,和c#还是有差距的,这样写感觉不是很优美呀)(编译的时候,需要使用:tsc --target es5 greeter.ts,只有高版本的javascript才支持这样的特性)
let passcode = "secret passcode";
class Employee {
private _fullName: string;
get fullName(): string {//格式,其实是个方法
return this._fullName;
}
set fullName(newName: string) {
if (passcode && passcode == "secret passcode") {
this._fullName = newName;
}
else {
console.log("Error: Unauthorized update of employee!");
}
}
}
let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
alert(employee.fullName);
}
6.静态属性(与C#的静态属性一样)
class Grid {
static origin = {x: 0, y: 0};//申明静态属性
calculateDistanceFromOrigin(point: {x: number; y: number;}) {
let xDist = (point.x - Grid.origin.x);//引用静态属性,记得使用类名
let yDist = (point.y - Grid.origin.y);
return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
}
constructor (public scale: number) { }
}
console.log(Grid.origin);//直接可以使用类名和静态属性计算了
let grid1 = new Grid(1.0);
let grid2 = new Grid(1.0);
console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));
Grid.origin.x=2;
Grid.origin.y=2;
console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));
console.log(Grid.origin);
7.抽象类
抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口,抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。
abstract class Animal {//关键字
abstract makeSound(): void;
move(): void {
console.log('roaming the earch...');
}
}
抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体。 然而,抽象方法必须包含 abstract关键字并且可以包含访问修饰符。
abstract class Department {
constructor(public name: string) {
}
printName(): void {
console.log('Department name: ' + this.name);
}
abstract printMeeting(): void; // 必须在派生类中实现
}
class AccountingDepartment extends Department {
constructor() {
super('Accounting and Auditing'); // constructors in derived classes must call super()
}
printMeeting(): void {
console.log('The Accounting Department meets each Monday at 10am.');
}
generateReports(): void {
console.log('Generating accounting reports...');
}
}
let department: Department; // ok to create a reference to an abstract type(注意,他是抽象类的对象)
department = new Department(); // error: cannot create an instance of an abstract class(抽象类不能实例化)
department = new AccountingDepartment(); // ok to create and assign a non-abstract subclass
//(这个非抽象类可以实例化,它是抽象类的子类)
department.printName();
department.printMeeting();
department.generateReports(); // error: method doesn't exist on declared abstract type
//抽象类的引用对象,只能调用抽象类的存在的方法,而不能调用子类的方法
8.类具有 实例部分与静态部分这两个部分。
class Greeter {
static standardGreeting = "Hello, there";
greeting: string;
greet() {
if (this.greeting) {
return "Hello, " + this.greeting;
}
else {
return Greeter.standardGreeting;
}
}
}
let greeter1: Greeter;
greeter1 = new Greeter();
console.log(greeter1.greet());
let greeterMaker: typeof Greeter = Greeter;
greeterMaker.standardGreeting = "Hey there!";
let greeter2: Greeter = new greeterMaker();
console.log(greeter2.greet());
let greeterMaker: typeof Greeter = Greeter;这个变量保存了这个类或者说保存了类构造函数。 然后我们使用 typeof Greeter,意思是取Greeter类的类型,而不是实例的类型。 或者更确切的说,"告诉我 Greeter标识符的类型",也就是构造函数的类型。 这个类型包含了类的所有静态成员和构造函数。
注意这句:let greeter2: Greeter = new greeterMaker();说明它是包含了构造函数了的,可以用它来实例化。但是greeterMaker变量不是类型,let greeter2:greeterMaker = new greeterMaker();这样使用时错误的。