TypeScript（类—继承—多态）

一、类的定义（class）

　　类(class)这个概念来源于OOP（Object Oriented Programming），也就是面向对象编程，OOP是一种计算机编程架构，其有着封装，继承，多态三种特性。而类在OOP中是实现信息封装的基础。类是一种用户定义类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。

　　es5：

        function Person(name) {
            this.name = name;
            this.run = function () {
                console.log(this.name)
            }
        }
        let p = new Person('李四')
        p.run()　　// 李四

　　ts：

class Person{       
    name:string;    /* 属性，前面省略public关键词   */
    constructor(name:string){   /* 构造函数，实例化类的时候触发的方法 */
        this.name=name
    }
    get():void{
        console.log(this.name)
    }
    set(name:string):void{
        this.name=name
        console.log(this.name)
    }
}
let p=new Person('李四')
p.get()     /* 李四 */
p.set('张三')     /* 张三 */
p.get()     /* 张三 */

二、继承（extends、super）

class Futher {
    name: string;
    constructor(name: string) {
        this.name = name
    }
    run(): void {
        console.log(this.name)
    }
}
let p1 = new Futher('张三')
p1.run() // 张三
class Child extends Futher {
    constructor(name: string) {
        super(name) /* 初始化父类的函数 */
    }
    work(): void {
        console.log(this.name)
    }
}
let p2 = new Child('李四')
p2.run() // 李四，子类继承父类的方法，若子类存在该方法则优先使用子类的方法
p2.work()   // 李四，子类可以拓展自己的方法

三、类里的修饰符（public、protected、private）

　　public：公有，不加修饰符默认公有。类里、子类、外部可以访问

　　protected：保护类型，类里、子类可以访问，类外不可访问

　　private：类里可以访问，子类、外部不可访问

class Futher {
    public name: string;    /* 公有 */
    protected age: number | null | undefined;    /* 保护 */
    private phone: number | null | undefined;    /* 私有 */
    constructor(name: string, age?: number, phone?: number) {
        this.name = name
        this.age = age
        this.phone = phone
    }
    run(): void {
        console.log(this.name, this.age, this.phone)
    }
}
class Child extends Futher {
    constructor(name: string, age: number, phone?: number) {
        super(name, age, phone) /* 初始化父类的函数 */
    }
    work(): void {
        console.log(this.name, this.age)
        /* console.log(this.name,this.age,this.phone) */  /* 子类添加private报错 */
    }
}
let p1 = new Futher('李四', 18, 123456)
let p2 = new Child('张三', 20, 654321)
p1.run() /* 李四 18 123456,类里可以访问public\protected\private */
p2.work()/*  张三 20,子类可以访问public\protected，子类访问private报错 */
console.log(p1.name) /*  张三,李四，外部可以访问public */
/* console.log(p1.name,p1.age,p1.age)*/ /* error，外部访问protected\private报错 */

四、静态方法（static）

class Person {
    public name: string;    /* 公有 */
    static sex:string='男'; /* 静态属性 */
    constructor(name: string) {
        this.name = name
    }
    run(): void {   /* 实例方法，实例后调用 */
        console.log(this.name)
    }
    static work():void{ /* 静态方法，不能直接调用类里的属性 */
        /* console.log(this.name) */  /* error,不能直接调用类里的属性 */
        console.log(Person.sex) /* 男 */
    }
}

五、多态

　　多态：父类定义一个方法不去实现，让继承他的子类去实现，每一个子类有不同的表现

　　多态属于继承

class Futher {
    public age: number;
    constructor(age: number) {
        this.age = age
    }
    counts(): void {
        console.log(this.age)
    }
}
class children1 extends Futher {
    constructor(age: number) {
        super(age)
    }
    counts(): void {    /* 多态，重写方法不执行父类方法 */
        console.log(this.age - 1)
    }
}
class children2 extends Futher {
    constructor(age: number) {
        super(age)
    }
    counts(): void {
        console.log(this.age + 1)
    }
}

六、抽象类（abstract）

　　用abstract定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现

　　1、抽象方法必须在抽象类中

　　2、抽象类和抽象方法是一个标准，定义标准后，子类中必须包含抽象定义的方法

abstract class Futher { /* 定义一个抽象方法 */
    public age: number;
    constructor(age: number) {
        this.age = age
    }
    abstract counts(): any; /* 抽象方法必须在抽象类中 */
}
class children extends Futher {
    constructor(age: number) {
        super(age)
    }
    counts(): void {    /* 子类中必须有抽象类中的抽象方法 */
        console.log(this.age - 1)
    }
}