TypeScript入門-類

學習Angular 2 ， 《揭祕Angular 2》讀書筆記。Angular2 選擇 TypeScript 做爲其官方最主要的構建語音，這意味着掌握 TypeScript 語音將更有利於高效地開發 Angular 應用。

類

傳統的 JavaScript 程序是使用函數和基於原型（Prototype）繼承來建立可重用的「類」，這對於習慣面向對象編程的開發者來講並不友好。TypeScript 中能夠支持使用基於類的面向對象編程。

類的例子

示例代碼以下：

class Car {
    engine: string;
    constructor(engine: string) {
        this.engine = engine;
    }
    drive(distanceInMeters: number = 0) {
        console.log(`A car runs ${ distanceInMeters }m powered by` + this.engine);
    }
}

上面聲明瞭一個汽車類，這個類有三個類成員：

• 類屬性 engine，可經過 this.engine 訪問

• 構造函數 constructor

• 方法 drive

下面實例化一個Car的對象，經過執行構造函數對其初始化。

let car = new Car('petrol');
car.drive(100); // 輸出：A car runs 100m powered by petrol

繼承與多態

封裝、繼承、多態是面向對象的三個特性。上面的例子中把汽車的行爲寫到一個類中，即所謂的封裝。在 TypeScript 中，使用 extends 關鍵字便可方便地實現繼承。示例代碼以下：

// 繼承自前文的 Car 類
class MotoCar extends Car {
    constructor(engine: string) { super(engine); }
}

class Jeep extends Car {
    constructor(engine: string) { super(engine); }
    drive(distanceInMeters: number = 100) {
        console.log("Jeep...")
        retrun super.drive(distanceInMeters);
    }
}

let tesla = new MotoCar('electricity');
let landRover: Car = new Jeep('petrol');

tesla.drive();    // 調用父類的 drive() 方法
landRover.drive(200);    // 調用子類的 drive() 方法

從上面的例子能夠看到，MotoCar 和 Jeep 是基類Car的子類，經過 extends 來繼承父類，子類能夠訪問父類的屬性和方法，也能夠重寫父類的方法。Jeep 類重寫了父類的 drive() 方法，這樣 drive() 方法在不一樣的類中就具備不一樣的功能，這就是多態。

修飾符

在類中的修飾器能夠分爲公共（public）、私有（private）和受保護（protected）三種類型。

public 修飾符
在 TypeScript 裏，每一個成員默認爲 public，能夠被自由訪問，咱們也能夠顯式地給 Car 類裏定義的成員加上 public 修飾符，示例代碼以下：

class Car {
    public engine: string;
    public constructor(engine: string) {
        this.engine = engine;
    }
    public drive(distanceInMeters: number = 0) {
        console.log(`A car runs ${ distanceInMeters }m powered by` + this.engine);
    }
}

private 修飾符
當類成員被標記爲 private 時，就不能在類的外部訪問它，示例代碼以下：

class Car {
    private engine: string;
    constructor(engine: string) {
        this.engine = engine;
    }
}

new Car('petrol').engine;    // 報錯：engine 屬性是私有的，只能在類內部訪問

protected 修飾符
protected 修飾符與 private 修飾符的行爲很類似，但有一點不一樣，protected 成員在派生類中仍然能夠訪問，示例代碼以下：

class Car {
    private engine: string;
    constructor(engine: string) {
        this.engine = engine;
    }
    drive(distanceInMeters: number = 0) {
        console.log(`A car runs ${ distanceInMeters }m powered by` + this.engine);
    }
}
class MotoCar extends Car {
    constructor(engine: string) { super(engine); }
    drive(distanceInMeters: number = 100) {
        super.drive(distanceInMeters);
    }
}
let tesla = new MotoCar('electricity');
console.log(tesla.drive());    // 正常
console.log(tesla.engine);    // 報錯

靜態屬性

類的靜態成員存在於類自己而不是類的實例上，咱們使用 類名. 來訪問靜態屬性。能夠使用 static 關鍵字來定義類的靜態屬性，示例代碼以下：

class Grid {
    static origin = {x: 0, y: 0};
    constructor(public scale: number) {}
    calculateDistanceFromOrigin(point: {x: number; y: number;}) {
        let xDist = (point.x - Grid.origin.x);
        let yDist = (point.y - Grid.origin.y);
        return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
    }
}
let grid1  = new Grid(1.0);

let grid2  = new Grid(5.0);

// 輸出：14.142...
console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));
// 輸出：2.828...
console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));

抽象類

TypeScript 有抽象類的概念，他是供其餘類繼承的基類，不能直接實例化。抽象類必須包含一些抽象方法，同時也能夠包含非抽象的成員。abstract 關鍵字用於定義抽象類和抽象方法。抽象類中的抽象方法不包含具體實現，可是必須在派生類中實現，示例代碼以下:

abstract class Person {
    abstract speak(): void;    // 必須在派生類中實現
    walking(): void {
        console.log('Walking on the road');
    }
}

class Male extends Person {
    speak(): void {
        console.log('How are you?');
    }
}

let person: Person;    // 建立一個抽象類的引用
person = new Person();    // 報錯，不能建立抽象類實例
person = new Male();    // 建立一個 Male 實例
person.speak();
person.walking();