使用 TypeScript 开发微信小程序（四）：类（Class）

从 ECMAScript 6 开始，可以使用基于类的面向对象的方式。

类

TypeScript 使用类：

   class Greeter {
        greeting: string;
        constructor(message: string) {            this.greeting = message;
        }
        greet() {            console.log("Hello, " + this.greeting);
        }
    }    let greeter = new Greeter("world");
    greeter.greet();

以上代码，声明一个 Greeter类。这个类有3个成员：一个叫做greeting的属性，一个构造函数和一个greet方法。在引用任何一个类成员的时候都用了this。 它表示我们访问的是类的成员。 使用new构造了Greeter类的一个实例，它会调用之前定义的构造函数，创建一个 Greeter类型的新对象，并执行构造函数初始化它。

构造函数

在TypeScript里，构造函数在使用 new 创建类实例的时候被调用。

   class Greeter {
        static standardGreeting = "Hello, there";
        greeting: string;
        greet() {            if (this.greeting) {                return "Hello, " + this.greeting;
            }            else {                return Greeter.standardGreeting;
            }
        }
    }    let greeter1: Greeter;
    greeter1 = new Greeter();    console.log(greeter1.greet());    let greeterMaker: typeof Greeter = Greeter;
    greeterMaker.standardGreeting = "Hey there!";    let greeter2: Greeter = new greeterMaker();    console.log(greeter2.greet());

以上代码，创建了一个叫做 greeterMaker 的变量。 这个变量保存了这个类或者说保存了类构造函数。 然后我们使用 typeof Greeter，意思是取Greeter类的类型，而不是实例的类型。 或者更确切的说，”告诉我 Greeter标识符的类型”，也就是构造函数的类型。 这个类型包含了类的所有静态成员和构造函数，在 greeterMaker 上使用 new，创建 Greeter 的实例。

继承

在TypeScript里，基于类的程序设计中最基本的模式是允许使用继承来扩展现有的类。

   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);
        }
    }    class Horse extends Animal {
        constructor(name: string) { super(name); }
        move(distanceInMeters = 45) {            console.log("Galloping...");
            super.move(distanceInMeters);
        }
    }    let sam = new Snake("Sammy the Python");    let tom: Animal = new Horse("Tommy the Palomino");
    sam.move();
    tom.move(34);

以上代码，使用 extends关键字来创建子类。 Horse 和 Snake 类是基类 Animal 的子类，并且可以访问其属性和方法。包含构造函数的派生类必须调用 super()，它会执行基类的构造方法。子类里可以重写父类的方法，Snake类 和 Hors e类都创建了move 方法，它们重写了从 Animal 继承来的 move 方法，使得 move 方法根据不同的类而具有不同的功能，即使 tom 被声明为 Animal 类型，但因为它的值是 Horse，tom.move(34) 会调用 Horse 里的重写方法。

公共，私有与受保护的修饰符

在TypeScript里，成员都默认为 public，使用 public 指定成员是可见的。

当成员被标记成private时，它就不能在声明它的类的外部访问。

protected修饰符与private修饰符的行为很相似，但有一点不同，protected成员在派生类中仍然可以访问。

   class Person {
        private id: string;
        public age: number;
        protected name: string;

        constructor(name: string) { 
            this.id = "123";            this.name = name; 
        }
    }    class Employee extends Person {
        private department: string;

        constructor(name: string, department: string) {
            super(name);            // this.id = "456"; // Error
            this.department = department;
        }

        public getElevatorPitch() {            return `Hello, my name is ${this.name} and I work in ${this.department}.`;
        }
    }    let howard = new Employee("Howard", "Sales");
    howard.age = 42;  
    console.log(howard.age);  
    // console.log(howard.id); // Error
    // console.log(howard.name); // Error
    console.log(howard.getElevatorPitch());

构造函数也可以被标记成 protected。 这意味着这个类不能在包含它的类外被实例化，但是能被继承。

   class Person {
        protected name: string;
        protected constructor(theName: string) { this.name = theName; }
    }

参数属性可以方便地在一个地方定义并初始化一个成员。 参数属性通过给构造函数参数添加一个访问限定符来声明。 使用 private限定一个参数属性会声明并初始化一个私有成员；对于public 和 protected 来说也是一样。

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

readonly修饰符

在TypeScript里，可以使用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"; // Error

存取器

TypeScript 支持通过 getters/setters 来截取对对象成员的访问。 它能帮助你有效的控制对对象成员的访问。

   let passcode = "secret passcode";    class User {
        private _name: string;

        get name(): string {            return this._name;
        }

        set name(newName: string) {            if (passcode && passcode == "secret passcode") {                this._name = newName;
            }            else {                console.log("Error: Unauthorized update of employee!");
            }
        }
    }    let user = new User();
    user.name = "admin";    if (user.name) {        console.log(user.name);
    }

存取器要求你将编译器设置为输出 ECMAScript 5 或更高。 不支持降级到 ECMAScript 3。 只带有 get 不带有 set 的存取器自动被推断为readonly。 这在从代码生成 .d.ts文件时是有帮助的，因为利用这个属性的用户会看到不允许够改变它的值。

静态属性

在TypeScript 里，可以创建类的静态成员，这些属性存在于类本身上面而不是类的实例上。

   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); 
    let grid2 = new Grid(5.0);    console.log(grid1.calculateDistanceFromOrigin({ x: 10, y: 10 }));    console.log(grid2.calculateDistanceFromOrigin({ x: 10, y: 10 }));

抽象类

在TypeScript里，抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 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'); 
        }
        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(); // Error
    department = new AccountingDepartment();
    department.printName();
    department.printMeeting();    // department.generateReports(); // Error

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

参考资料

• TypeScript官网
• TypeScript中文网

其他

• 完整代码：https://github.com/guyoung/GyWxappCases/tree/master/TypeScript
• 微信小程序Canvas增强组件WeZRender：https://github.com/guyoung/WeZRender