LayaBox学习小札-04 TypeScript语言的class


请尊重原作者的工作,转载时请务必注明转载自:www.xionggf.com

1 基本类定义

举例说明:

class Greeter // 迎宾类
{
    /*public*/ greeting: string; // 类的属性成员,默认地如果不加public关键字声明的话,访问权限也依然是“公有”

    // constructor是类的构造函数,constructor是一个保留字,专门用于定义类的构造函数
    constructor(message: string)
    {
        this.greeting = message; // 在类成员函数里面引用类非静态成员 必须要在前面加上关键字this
    }

    // 定义一个类成员函数,不需要在成员函数前面添加function关键字,如果函数内部的return语句可以明确推断出返回
    // 类型,也不需要在函数的后面声明返回的数据类型值
    /*function*/greet()/*: string*/
    {
        return "Hello, " + this.greeting;
    }
}

// 使用new关键字实例化出一个Greeter类型的对象。调用new关键字实例化对象会调用类的constuctor函数
let greeter = new Greeter("world");

2 类的继承

举例说明

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

// 使用extend关键字继承实现基类Animal
class Snake extends Animal
{
    // 与前一个例子的不同点是,派生类包含了一个构造函数,必须调用 super(),它会执行基类的构造函数。 而且,
    // 在构造函数里访问this的属性之前,一定要调用 super()。 这个是TypeScript强制执行的一条重要规则。
    constructor(name: string) { super(name); }
    // 重载实现基类的move函数
    move(distanceInMeters = 5) {
        console.log("Slithering...");
        super.move(distanceInMeters);
    }
}

// 使用extend关键字继承实现基类Animal
class Horse extends Animal 
{
    constructor(name: string) { super(name); }
    move(distanceInMeters = 45) {
        console.log("Galloping...");
        super.move(distanceInMeters);
    }
}

// sam变量的类型是Snake类型,虽然在声明变量时没明确声明,但是用类型推断机制可以确定其类型为Snake
let sam = new Snake("Sammy the Python");
// tom变量的类型明确声明为Animal,但是赋值一个子类Horse的实例变量给它。这种方式和C++里面的基类指针
// 指向子类对象产生多态性效果是一致的。
let tom: Animal = new Horse("Tommy the Palomino");
sam.move();  // 调用的是Snake类的move成员函数
tom.move(34); // 调用的是Horse类的move成员函数

3 成员属性的访问权限

基本上在TypeScript语言中,类成员的访问权限规则和C++/C#等语言是一致的。类的构造函数也可以被标记成 protected。 这意味着这个类不能在包含它的类外被实例化,但是能被继承。比如:

class Person 
{
    protected name: string;
    // 声明作为基类的Person的构造函数的访问权限是“保护”的
    protected constructor(theName: string) { this.name = theName; }
}

// Employee 能够继承 Person
class Employee extends Person 
{
    private department: string;

    constructor(name: string, department: string) 
    {
        super(name);
        this.department = department;
    }

    public getElevatorPitch() 
    {
        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
    }
}

let howard = new Employee("Howard", "Sales");
let john = new Person("John"); // 错误: 'Person' 的构造函数是被保护的.

4 readonly修饰符

你可以使用 readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。然后在运行时就不能改变它的值了,如下代码所示:

class Octopus {
    readonly name: string;
    readonly numberOfLegs: number = 8; // 该属性是public的,但是readonly的,所以只能在构、
                                       // 造函数中进行一次赋值然后就不能改变了
    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 是只读的

5 在构造函数里面声明并立即定义成员属性

举例说明:

class Animal
{
    /*private name : string;*/ // 原本要定义一个成员属性要显式地声明,现在可以直接在类构造函数中,
                               // 通过加上访问权限修饰符,隐式地进行声明定义

    // 在参数name前加上private修饰符,等同于声明了一个名为name的私有string类型的成员变量name
    constructor(private name: string) { }
    move(distanceInMeters: number) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
}

6 get/set访问符号

Typescript语言支持和C#类似的get/set访问符号,用以定义对类成员变量的获取和设置,如下代码:

let passcode = "secret passcode";

class Employee {
    private _fullName: string;

    // 声明一个get,
    get fullName(): string {
        return this._fullName;
    }

    // 声明一个set
    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"; // fullName是一个setter,所以不用类似于调用函数的方式去设置值
if (employee.fullName) {
    alert(employee.fullName); // fullName是一个getter,所以用在后面不用加上()就能获取到_fullName的值
}

7 类的静态属性

类的静态属性成员的规则和C#,C++等语言类似,如下代码:

class Grid {
    static origin = {x: 0, y: 0}; // 静态成员变量,而且是一个接口
    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;
    }
    constructor (public scale: number) { }
}

let grid1 = new Grid(1.0);  // 1x scale
let grid2 = new Grid(5.0);  // 5x scale

console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));
console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));

8 抽象类

抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口,抽象类可以包含成员的实现细节。abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。其规则基本类似于Java语言。如下代码:

abstract class Animal
{
    abstract makeSound(): void; // 抽象方法
    move(): void {
        console.log('roaming the earch...');
    }
}

抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。抽象方法的语法与接口方法相似。两者都是定义方法签名但不包含方法体。 然而,抽象方法必须包含 abstract关键字并且可以包含访问修饰符。而且必须在派生类中实现这个抽象方法。

abstract class Department
{
    constructor(public name: string) {
    }

    printName(): void {
        console.log('Department name: ' + this.name);
    }

    abstract printMeeting(): void; // 必须在派生类中实现
}

class AccountingDepartment extends Department 
{
    constructor() {
        super('Accounting and Auditing'); // 在派生类的构造函数中必须调用 super()
    }

    printMeeting(): void {
        console.log('The Accounting Department meets each Monday at 10am.');
    }

    generateReports(): void {
        console.log('Generating accounting reports...');
    }
}

let department: Department; // 允许创建一个对抽象类型的引用
department = new Department(); // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment(); // 允许对一个抽象子类进行实例化和赋值
department.printName();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在

上一章
下一章
返回首页