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();
    原文作者:wuweisen
    原文地址: https://segmentfault.com/a/1190000008947651
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞