1.继承
class Person {
constructor(public name: string) {
}
}
class Men extends Person { // 继承Person类
constructor(name: string) { // 构造函数必须调用super方法
super(name)
}
}
子类必须调用super方法，执行父类的constructor方法
实例属性可在构造函数的参数列表中声明并赋值
2.公共，私有与受保护的修饰符
（1）public
类的成员默认都为public。
（2）private
私有成员，仅可在本类中访问。
class Person {
constructor(public name: string) {
// this.name = name
}
}
class Men extends Person{
constructor(name: string,private sex: string) { // 声明私有成员sex
super(name)
}
getSex(): string {
return this.sex
}
}
let m = new Men('ma','fale')
console.log(m.getSex()) // 正确，可以通过实例方法访问private成员
console.log(m.sex) // 错误，sex是私有成员，仅可在类内部访问
（3）protected
保护成员，protected成员在派生类中仍然可以访问。
class Person {
protected age: number; // 在父类中声明保护成员age
constructor(public name: string) {
this.age = 0
}
}
class Men extends Person{
constructor(name: string) {
super(name)
}
getAge(): number {
return this.age // 子类中可以访问父类中声明的age属性
}
}
let m = new Men('ma')
console.log(m.getAge()) // 正确，可以通过实例方法访问protected成员
console.log(m.age) // 错误，无法直接访问protected成员
（4）readonly
使用readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。
class Men extends Person{
constructor(name: string,readonly sex: string) {
super(name)
}
getAge(): number {
return this.age
}
}
let m = new Men('ma','fale')
m.sex = 'mefale' // 错误，readonly属性不可修改
3.存取器
通过get/set控制对成员的访问。
只带有 get不带有 set的存取器自动被推断为 readonly
class Person {
protected age: number;
private _height: number; // 私有属性
constructor(public name: string) {
this.age = 0
this._height = 30
}
get height(): number { // public属性的get方法
return this._height
}
set height(h: number) { // public属性的set方法。无返回类型
if(h > 30) { // 可在此函数中增加set的条件
this._height = h
}
}
}
let p = new Person('ma')
p.height = 20 // 调用set方法，不通过验证
console.log(p.height) // 30
4.静态属性static
类的静态成员存在于类本身上面而不是类的实例上。用static关键字声明静态成员，用类名.静态成员可直接访问。
class Person {
protected age: number;
static height: number = 30; // 静态属性
constructor(public name: string) {
this.age = 0
}
}
console.log(Person.height) // 30。静态属性，可直接用类名.成员名访问
5.抽象类
抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。
抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体。 然而，抽象方法必须包含 abstract关键字并且可以包含访问修饰符。
abstract class AB {
constructor(public name: string) {
}
abstract getName(): string; // 定义抽象方法，必须在子类中实现
}
class A extends AB {
constructor(name: string){
super(name)
}
getName(): string { // 实现抽象方法
return 'this is getName function!' + this.name
}
getA(): string { // 特有方法
return 'this is getA function!'
}
}
let a = new A('zhou')
console.log(a.getName())
console.log(a.getA())
let ab: AB = new A('ting') // 类型为抽象类AB
console.log(ab.getName()) // 错误，getName方法在A类上才有
