类

calss A {name: stringconstructor(name:string) {this.name = name}greet() {return 'hello,' + this.name}
}
let people = new A('RenNing')

继承

子类是一个派生类，他派生自父类（基类），通过 extends关键字

派生类通常被称作 子类，基类通常被称作 超类。

派生类包含了一个构造函数，它 必须调用 super()

公共、私有、受保护的修饰符

public

ts中 成员默认为public

private

不能再声明他的类的外部访问

子类无法访问 private

class Animal {private name: string;constructor(thenname: string) {this.name = theName}
}
new Animal('cat').name //报错

protected

protected成员可以再派生类中访问

构造函数（constructor）被标记成 protected 后，不能实例化该类，当是能被继承

class A{protected constructor() {}
}
class B extends A {}
let a = new A() //错误-A的构造函数时被保护的
let b = new B() //ok

readonly修饰符

readonly关键字将属性设置为只读，只读属性必须再声明时构造函数里被初始化。

class A {readonly name: string;readonly age: number = 18
}
(new A()).name = 1 //报错

参数属性

参数属性可以方便地让我们在一个地方定义并初始化一个成员

改造上面的例子后

class A {constructor(readonly name: string, readonly age: number) {}say() {console.log(this.name,this.age)}
}
let a = new A('Ren', 18)
a.say() //Ren 18

我们把声明和赋值合并至一处

存取器

ts 指出通过getter/setters来截取对象成员访问。

let passcode = 'searet passcode'
class Employee {private _fullName: string;get fullName() :string {return this._fullName}set fullName(newValue: string) {if(passcode && passcode == 'secret passcode') {this._fullName = newValue}else {console.log('Error Unauthorized update of employee')}}
}
let employee = new Employee()

只带有 get不带有 set的存取器自动被推断为 readonly。

静态属性

使用 static定义

class A {static name: string = 'RenNing'
}
console.log(A.name)//RenNing

抽象类abstract

作为其他派生类的基类使用，不会被实例化，可定义抽象类、抽象方法

abstract class A {abstract makeSound(): void;move: void {console.log('roamin the earch...')}
}

抽象类中的抽象方法不包含具体实现，并且必须再派生类中事项，

与接口方法相似：只定义方法签名，但不包含方法体。abstract 可以包含访问修饰符

abstract class A {abstract say() :void//必须在派生类中实现sing(){console.log('sing-A')}
}
class B extends A {say():void{console.log('say-B')}song() :void {console.log('song-B')}
}
let point: A
point = new A()//错误：不能实例化抽象类
point = new B()
point.say()say-B
point.song()//错误：方法再声明抽象类中不存在let point: B
point = new B()
point.say()//say-B
point.song()//song-B
point.sing()//sing-A

高级技巧

取类的 类型 **typeof 类名， 这个类型包含了类的所有静态成员和构造函数

class A {static name: string = "Ren"age: number = 18
}
let aMaker: type A = A
console.log(A.name)//Renlet b: A = new A()
console.log(b.age)//18console.log(typeof A)// function

把类当做接口使用

类定义会创建两个东西：类的实例类型和一个构造函数

class A {x: number;y:number}
interface Point3d extends Point {z: number}
let point3d: Point2d = {x: 1, y: 2, z: 3}

无法直接实例化

接口继承类

构造函数被 protected 修饰

抽象类