基本类
new实例化类时，会创建一个Animal类型的新对象，并执行constructor初始化它：
class Animal {
char: string; // 测处为分号不是逗号
constructor (msg: string) {
this.char = msg;
}
say() {
return `hello ${this.char}`
}
};
let myAn = new Animal('dog');
继承
允许使用继承来扩展现有的类，通过extends关键字：
class Animal {
move(len: number = 0) {
console.log(`animal moved ${len} m`)
}
}
class Dog extends Animal {
bark() {
console.log('wof, wof');
}
}
const dog = new Dog();
dog.bark(); // Dog类本身的方法
dog.move(10); //从Animal类继承来的方法
注释：此例子中，Dog类是一个派生类，它派生自Animal基类，派生类被称作 子类，基类被称作 超类。
在子类里重写父类的方法
class Animal {
name: string,
constructor(theName: string) {this.name = theName;}
move(len: number = 0) {
console.log(`${this.name} moved ${len}m.`);
}
}
class Snake extends Animal {
constructor(name: string) { super(name); }
move(len = 5) {
console.log("Slithering...");
super.move(len);
}
}
class Horse extends Animal {
constructor(name: string) {super(name);}
move(len = 45) {
console.log("Galloping...")
super.move(len);
}
}
let sam = new Snake("Sammy");
let tom:Animal = new Horse("Tommy");
sam.move();
tom.move(34);
输出结果：Slithering...
Sammy moved 5m
Galloping...
Tommy moved 34m
说明：派生类包含一个构造函数时，它必须调用super()，它会执行基类的构造函数。
公共，私有与受保护的修饰符
默认为public
ts中定义的类中的成员默认为public，成员不用其他修饰符修饰时，可以自由的访问程序里定义的成员。
理解private：私有
当成员被标记为private，它就不能被声明它的类的外部访问。
class Animal {
private name: string;
constructor(theName: string) { this.name = theName; }
}
new Animal('Cat').name; // error: name is private
理解protected：受保护的
protected和private相似，但有一点，protected成员在派生类中仍然可以访问。
若构造很熟constructor被标记为protected，则该类不能被实例化。
readonly修饰符
只读属性必须在声明时或构造函数里被初始化。
参数属性
参数属性通过给构造函数参数添加一个访问限定符来声明。使用private，public，protected限定一个参数属性会声明并初始化一个私有/公共/被保护的成员。
class Animal {
constructor(private name: string) {}
move(meter: number) {
console.log(`${this.name} moved ${meter}m`);
}
}
存取器
通过get和set来截取对对象成员的访问。
静态属性：static
使用static定义的成员，每个实例想要访问这个成员时，都需要在成员前面加上类名，如同实例属性上使用this.。
class Grid {
static origin = 10;
constructor (public scale: number) {}
lowLen(x: number) {
let length01 = x*this.scale - Grid.origin;
return length01;
}
}
let grid01 = new Grid(2.0);
console.log(grid01.lowLen(60)); //110
抽象类：abstract
1、抽象类作为其他派生类的基类使用，一般不能直接被实例化。
2、抽象类中的抽象方法不包含具体实现且必须在派生类中实现。
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'); // 在派生类的构造函数中必须调用 super()
}
printMeeting(): void {
console.log('The Accounting Department meets each Monday at 10am.');
}
generateReports(): void {
console.log('Generating accounting reports...');
}
}
let department: Department; // 允许创建一个对抽象类型的引用
department = new Department(); // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment(); // 允许对一个抽象子类进行实例化和赋值
department.printName();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在
高级技巧
把类当做接口使用
class Point {
x: number;
y: number;
}
interface Point3d extends Point {
z: number;
}
let point3d: Point3d = {x: 1, y: 2, z: 3};
