摘要：抽象類抽象類做為其它字類的基類使用，一般不會直接被實例化。抽象類中可以包含具體實現，接口不能。抽象類在運行時是可見的，可以通過判斷。接口只能描述類的公共部分，不會檢查私有成員，而抽象類沒有這樣的限制。

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

let greeter = new Greeter("world");

super 作為函數調用時，代表父類的構造函數。子類的構造函數必須執行一次 super 函數，并且在構造函數里訪問 this 的屬性之前一定要調用 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 雖然代表了父類 Animal 的構造函數，但是返回的是子類 Snake 的實例，即 super 內部的 this 指的是 Snake 的實例，因此 super() 在這里相當于 Animal.prototype.constructor.call(this)。

在 TypeScript 中，所有訪問修飾符默認為 public，這個和 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 修飾的變量，不允許在類的外面使用，子類中也不允許訪問：

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

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

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

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

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; // 不能將類型“Employee”分配給類型“Animal”。類型具有私有屬性“name”的多帶帶聲明。

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

構造函數可以被 protected 修飾，修飾后的類無法被實例化，只能被繼承。

readonly 可以將屬性設置為只讀，只讀屬性只能在聲明時或者構造函數里進行初始化：

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"; // 錯誤! name 是只讀的

參數屬性可以方便地在一個類里定義并初始化一個成員：

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

參數屬性通過給構造函數參數前面添加一個訪問限定符來聲明。使用 private 限定一個參數屬性會聲明并初始化一個私有成員；public 和 protected 也是一樣。

TypeScript 中的類支持取值函數(getter)、存值函數(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);
}

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

只帶有 get 不帶有 set 的存取器會自動被推斷為 readonly。

TypeScript 中的類支持靜態成員，可以在沒有實例化的情況下進行訪問，使用 static 進行修飾：

class Grid {
    static origin = { x: 0, y: 0 };
    calculateDistanceFromOrigin(point: { x: number; y: number }) {
        // 類里使用靜態成員需要加上類名，使用訪問和 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}

靜態方法調用不了實例化方法和實例化屬性，因為靜態域加載是在解析階段，而實例化是在初始化階段，所以靜態方法里面不能調用本類的方法和屬性，可以調用靜態屬性和靜態方法。

抽象類做為其它字類的基類使用，一般不會直接被實例化。不同于接口，抽象類可以包含成員的實現細節。abstract 關鍵字是用于定義抽象類和在抽象類內部定義抽象方法：

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

抽象類中的抽象方法不包含具體實現并且必須在字類中實現。抽象方法必須包含 abstract 關鍵字并且可以包含訪問修飾符。

類定義會創建兩個東西：類的實例類型和一個構造函數。因為類可以創建出類型，所以可以在使用接口的地方使用類：

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

interface Point3d extends Point {
    z: number;
}

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

類可以實現（implement）接口。通過接口可以強制指明類遵守某個契約。也可以在接口中聲明一個方法，然后要求類去具體實現它。

接口不可以被實例化，實現接口必須重寫接口中的抽象方法。

類可以實現（implement）多個接口，但只能擴展（extends）自一個抽象類。

抽象類中可以包含具體實現，接口不能。

抽象類在運行時是可見的，可以通過 instanceof 判斷。接口則只在編譯時起作用。

接口只能描述類的公共（public）部分，不會檢查私有成員，而抽象類沒有這樣的限制。