TypeScript 学习笔记（三）

类：

　　1、TypeScript 是面向对象的 JavaScript，类描述了创建的对象共同的属性和方法

　　2、类通过关键字 class 声明，使用 extends 关键字进行继承

　　3、在引用一个类成员时使用 this 关键字，表明该成员是我们访问的类的成员

　　4、派生类通常被称为子类，而基类通常称为超类

　　5、派生类包含了一个构造函数，它必须调用 super()，它会执行基类的构造函数。

　　      而且，在构造函数里访问 this的属性之前，我们一定要调用 super()。 这个是TypeScript强制执行的一条重要规则。

class base {
    name: string;
    str: string;
    constructor(name: string) {
        this.name = name;
        // 模板字符串
        this.str = `Hello ${this.name},
        nice to meet you!`;
    }
    sayHello() {
        alert(this.str);
    }
}

class one extends base {
    sayHello() {
        this.str = this.str + "\nIn one";
        super.sayHello();    // 使用超类地方法
    }
}

// 弹出 Hello Lemon,
// nice to meet you!
// In one
new one("Lemon").sayHello();

访问修饰符：

　　1、public：类里成员默认为 public 的，公有成员可在类外被访问

　　2、protected：保护成员只能在该类以及其子类才能被访问

　　3、private：私有成员只能在该类中才能被访问

补充：

　　1、TypeScript 使用的是结构性系统，当比较两种不同的类时，若所有成员都是兼容的，则它们的类型也是是兼容的

　　2、若该类带有 private 或 protected 成员，则只有当另一个类中对应存在该类型成员，且它们都来自同一处声明，它们才是兼容的

抽象类：

　　1、作为其他派生类的基类使用，一般不会直接被实例化

　　2、抽象类可以包含成员的实现细节，但必须包含关键字 abstract，并且可以包含访问修饰符

abstract class base {
    constructor() {
        alert("In base");
    }
    public say() {}
    public abstract run();
}

class test extends base {
    // 若没给 _str 赋值，则默认为 undefined
    private _str: string = "";
    constructor() {
        // 子类需要在构造函数里调用父类的构造函数
        super();
        alert("In test");
    }
    run() {
        // 需要使用 this 关键字
        this._str = this._str + "Running\n";
    }
    say() {
        this._str = this._str + "Saying\n";
    }
    getStr() {
        alert(this._str);
    }
}

let t: test = new test(); // In base 然后 In test
t.run();
t.getStr();  // Running
t.say();
t.getStr();  // Running
             // Saying