TypeScript入门之class

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类上才有