摘要：抽象類(lèi)抽象類(lèi)做為其它字類(lèi)的基類(lèi)使用，一般不會(huì)直接被實(shí)例化。抽象類(lèi)中可以包含具體實(shí)現(xiàn)，接口不能。抽象類(lèi)在運(yùn)行時(shí)是可見(jiàn)的，可以通過(guò)判斷。接口只能描述類(lèi)的公共部分，不會(huì)檢查私有成員，而抽象類(lèi)沒(méi)有這樣的限制。

class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

let greeter = new Greeter("world");

super 作為函數(shù)調(diào)用時(shí)，代表父類(lèi)的構(gòu)造函數(shù)。子類(lèi)的構(gòu)造函數(shù)必須執(zhí)行一次 super 函數(shù)，并且在構(gòu)造函數(shù)里訪(fǎng)問(wèn) this 的屬性之前一定要調(diào)用 super()：

class Animal {
    name: string;
    constructor(theName: string) {
        this.name = theName;
    }
    move(distanceInMeters: number = 0) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

class Snake extends Animal {
    constructor(name: string) {
        super(name);
    }
    move(distanceInMeters = 5) {
        console.log("Slithering...");
        super.move(distanceInMeters);
    }
}

super 雖然代表了父類(lèi) Animal 的構(gòu)造函數(shù)，但是返回的是子類(lèi) Snake 的實(shí)例，即 super 內(nèi)部的 this 指的是 Snake 的實(shí)例，因此 super() 在這里相當(dāng)于 Animal.prototype.constructor.call(this)。

在 TypeScript 中，所有訪(fǎng)問(wèn)修飾符默認(rèn)為 public，這個(gè)和 JavaScript 是一致的：

// 這和上面例子是一致的
class Animal {
    public name: string;
    public constructor(theName: string) {
        this.name = theName;
    }
    public move(distanceInMeters: number) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

private 意為私有，使用 private 修飾的變量，不允許在類(lèi)的外面使用，子類(lèi)中也不允許訪(fǎng)問(wèn)：

class Animal {
    private name: string;
    constructor(theName: string) {
        this.name = theName;
    }
}

new Animal("Cat").name; // Error

在 TypeScript 中，如果兩個(gè)類(lèi)的所有成員的類(lèi)型都是兼容的，這就表示兩個(gè)類(lèi)是兼容的。

但是，一個(gè)類(lèi)里有 private、protected 修飾的成員，另一個(gè)類(lèi)中的變量必須擁有來(lái)自同一處聲明的相同修飾的變量，這兩個(gè)類(lèi)才算是兼容的：

class Animal {
    private name: string;
    constructor(theName: string) {
        this.name = theName;
    }
}

class Rhino extends Animal {
    constructor() {
        super("Rhino");
    }
}

class Employee {
    private name: string;
    constructor(theName: string) {
        this.name = theName;
    }
}

let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");

animal = rhino;
animal = employee; // 不能將類(lèi)型“Employee”分配給類(lèi)型“Animal”。類(lèi)型具有私有屬性“name”的多帶帶聲明。

protected 唯一比 private 修飾的成員多出的權(quán)限在于，protected 修飾的成員可以在子類(lèi)中使用，但仍不允許在類(lèi)的外面使用。

構(gòu)造函數(shù)可以被 protected 修飾，修飾后的類(lèi)無(wú)法被實(shí)例化，只能被繼承。

readonly 可以將屬性設(shè)置為只讀，只讀屬性只能在聲明時(shí)或者構(gòu)造函數(shù)里進(jìn)行初始化：

class Octopus {
    readonly name: string;
    readonly numberOfLegs: number = 8;
    constructor(theName: string) {
        this.name = theName;
    }
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // 錯(cuò)誤! name 是只讀的

參數(shù)屬性可以方便地在一個(gè)類(lèi)里定義并初始化一個(gè)成員：

// 這里和上面定義的類(lèi)是一樣的
class Octopus {
    readonly numberOfLegs: number = 8;
    // 把聲明和賦值合并到一起
    constructor(readonly name: string) {}
}

參數(shù)屬性通過(guò)給構(gòu)造函數(shù)參數(shù)前面添加一個(gè)訪(fǎng)問(wèn)限定符來(lái)聲明。使用 private 限定一個(gè)參數(shù)屬性會(huì)聲明并初始化一個(gè)私有成員；public 和 protected 也是一樣。

TypeScript 中的類(lèi)支持取值函數(shù)(getter)、存值函數(shù)(setter)：

let passCode = "secret passCode";

class Employee {
    // 私有屬性
    private _fullName: string;

    // getter
    get fullName(): string {
        return this._fullName;
    }

    // setter
    set fullName(newName: string) {
        if (passCode && passCode == "secret passCode") {
            this._fullName = newName;
        } else {
            console.log("Error: Unauthorized update of employee!");
        }
    }
}

let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
    alert(employee.fullName);
}

存取器必須要編譯器設(shè)置（compilerOptions.target）輸出為 ES6 或更高。

只帶有 get 不帶有 set 的存取器會(huì)自動(dòng)被推斷為 readonly。

TypeScript 中的類(lèi)支持靜態(tài)成員，可以在沒(méi)有實(shí)例化的情況下進(jìn)行訪(fǎng)問(wèn)，使用 static 進(jìn)行修飾：

class Grid {
    static origin = { x: 0, y: 0 };
    calculateDistanceFromOrigin(point: { x: number; y: number }) {
        // 類(lèi)里使用靜態(tài)成員需要加上類(lèi)名，使用訪(fǎng)問(wèn)和 this 相同
        let xDist = point.x - Grid.origin.x;
        let yDist = point.y - Grid.origin.y;
        return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
    }
    constructor(public scale: number) {}
}

let grid = new Grid(1.0);

console.log(grid.calculateDistanceFromOrigin({ x: 10, y: 10 }));
// 14.142135623730951
console.log(Grid.origin);
// Object {x: 0, y: 0}

靜態(tài)方法調(diào)用不了實(shí)例化方法和實(shí)例化屬性，因?yàn)殪o態(tài)域加載是在解析階段，而實(shí)例化是在初始化階段，所以靜態(tài)方法里面不能調(diào)用本類(lèi)的方法和屬性，可以調(diào)用靜態(tài)屬性和靜態(tài)方法。

抽象類(lèi)做為其它字類(lèi)的基類(lèi)使用，一般不會(huì)直接被實(shí)例化。不同于接口，抽象類(lèi)可以包含成員的實(shí)現(xiàn)細(xì)節(jié)。abstract 關(guān)鍵字是用于定義抽象類(lèi)和在抽象類(lèi)內(nèi)部定義抽象方法：

abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log("moving...");
    }
}

抽象類(lèi)中的抽象方法不包含具體實(shí)現(xiàn)并且必須在字類(lèi)中實(shí)現(xiàn)。抽象方法必須包含 abstract 關(guān)鍵字并且可以包含訪(fǎng)問(wèn)修飾符。

類(lèi)定義會(huì)創(chuàng)建兩個(gè)東西：類(lèi)的實(shí)例類(lèi)型和一個(gè)構(gòu)造函數(shù)。因?yàn)轭?lèi)可以創(chuàng)建出類(lèi)型，所以可以在使用接口的地方使用類(lèi)：

class Point {
    x: number;
    y: number;
}

interface Point3d extends Point {
    z: number;
}

let point3d: Point3d = { x: 1, y: 2, z: 3 };

類(lèi)可以實(shí)現(xiàn)（implement）接口。通過(guò)接口可以強(qiáng)制指明類(lèi)遵守某個(gè)契約。也可以在接口中聲明一個(gè)方法，然后要求類(lèi)去具體實(shí)現(xiàn)它。

接口不可以被實(shí)例化，實(shí)現(xiàn)接口必須重寫(xiě)接口中的抽象方法。

類(lèi)可以實(shí)現(xiàn)（implement）多個(gè)接口，但只能擴(kuò)展（extends）自一個(gè)抽象類(lèi)。

抽象類(lèi)中可以包含具體實(shí)現(xiàn)，接口不能。

抽象類(lèi)在運(yùn)行時(shí)是可見(jiàn)的，可以通過(guò) instanceof 判斷。接口則只在編譯時(shí)起作用。

接口只能描述類(lèi)的公共（public）部分，不會(huì)檢查私有成員，而抽象類(lèi)沒(méi)有這樣的限制。