类

传统的JavaScript程序使用函数和基于原型的继承来创建可重用的组件。Typescript则在此基础上加入了语法糖类。

了解Javascript的基础内容请参考对象原型。

声明类

我们首先来看一个例子

  1. class Greeter {
  2.     greeting: string;
  3.     constructor(message: string) {
  4.         this.greeting = message;
  5.     }
  6.     greet() {
  7.         return "Hello, " + this.greeting;
  8.     }
  9. }
  11. let greeter = new Greeter("world");

如果你使用过C#或Java，你会对这种语法非常熟悉。 我们声明一个 Greeter类。这个类有3个成员：一个叫做 greeting的属性，一个构造函数和一个 greet方法。

你会注意到，我们在引用任何一个类成员的时候都用了 this。 它表示我们访问的是类的成员。

最后一行，我们使用 new构造了 Greeter类的一个实例。 它会调用之前定义的构造函数，创建一个 Greeter类型的新对象，并执行构造函数初始化它。

继承

在TypeScript里，我们可以使用常用的面向对象模式。 基于类的程序设计中一种最基本的模式是允许使用继承来扩展现有的类。

看下面的例子：

  1. class Animal {
  2.     move(distance: number = 0) {
  3.         console.log(`Animal moved ${distance}m.`);
  4.     }
  5. }
  7. class Dog extends Animal {
  8.     bark() {
  9.         console.log('Woof! Woof!');
  10.     }
  11. }
  13. const dog = new Dog();
  14. dog.bark();
  15. dog.move(10);
  16. dog.bark();

这个例子展示了最基本的继承：类从基类中继承了属性和方法。这里，Dog是一个 派生类，通过 extends关键字使它从 Animal 基类中派生出来。 派生类通常被称作 子类，基类通常被称作 超类或父类。

因为 Dog继承了 Animal的功能，因此我们可以创建一个 Dog的实例，它能够 bark()和 move()。

下面我们来看个更加复杂的例子。

  1. class Animal {
  2.     name: string;
  3.     constructor(theName: string) { this.name = theName; }
  5.     move(distance: number = 0) {
  6.         console.log(`${this.name} moved ${distance}m.`);
  7.     }
  8. }
  10. class Snake extends Animal {
  11.     constructor(name: string) { super(name); }
  13.     move(distance = 5) {
  14.         console.log("Slithering...");
  15.         super.move(distance);
  16.     }
  17. }
  19. class Horse extends Animal {
  20.     constructor(name: string) { super(name); }
  22.     move(distance = 45) {
  23.         console.log("Galloping...");
  24.         super.move(distance);
  25.     }
  26. }
  28. let sam = new Snake("Sammy the Python");
  29. let tom: Animal = new Horse("Tommy the Palomino");
  31. sam.move();
  32. tom.move(34);

与前一个例子的不同点是，这次两个派生类包含了一个构造函数，它必须调用 super()，它会执行基类的构造函数。 而且，在构造函数里访问 this的属性之前，我们 必须要调用 super()，这个是TypeScript强制规定的。

修饰符

public

如果你对其它语言中的类比较了解，就会注意到我们在之前的代码里并没有使用 public来做修饰；例如，C#要求必须明确地使用 public指定成员是可见的。 在TypeScript里，成员都默认为 public。在上面的例子里，我们可以自由的访问程序里定义的成员。

private

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

  1. class Animal {
  2.     private name: string;
  3.     constructor(theName: string) { this.name = theName; }
  4. }
  6. new Animal("Cat").name; // 错误: 'name' 是私有的.

protected

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

  1. class Person {
  2.     protected name: string;
  3.     constructor(name: string) { this.name = name; }
  4. }
  6. class Employee extends Person {
  7.     private department: string;
  9.     constructor(name: string, department: string) {
  10.         super(name)
  11.         this.department = department;
  12.     }
  14.     public getElevatorPitch() {
  15.         return `Hello, my name is ${this.name} and I work in ${this.department}.`;
  16.     }
  17. }
  19. let howard = new Employee("Howard", "Sales");
  20. console.log(howard.getElevatorPitch());
  21. console.log(howard.name); // 错误

注意，我们不能在 Person类外使用 name，但是我们仍然可以通过 Employee类的实例方法访问，因为 Employee是由 Person派生而来的。

readonly

你可以使用 readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。

  1. class Octopus {
  2.     readonly name: string;
  3.     readonly numberOfLegs: number = 8;
  4.     constructor (theName: string) {
  5.         this.name = theName;
  6.     }
  7. }
  8. let dad = new Octopus("Man with the 8 strong legs");
  9. dad.name = "Man with the 3-piece suit"; // 错误! name 是只读的.

get/set

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

下面来看如何把一个简单的类改写成使用 get和 set。 首先，我们从一个没有使用存取器的例子开始。

  1. class Employee {
  2.     fullName: string;
  3. }
  5. let employee = new Employee();
  6. employee.fullName = "Bob Smith";
  7. if (employee.fullName) {
  8.     console.log(employee.fullName);
  9. }

下面这个版本里，我们先检查用户密码是否正确，然后再允许其修改员工信息。 我们把对 fullName的直接访问改成了可以检查密码的 set方法。 我们也加了一个 get方法，让上面的例子仍然可以工作。

  1. let passcode = "secret passcode";
  3. class Employee {
  4.     private _fullName: string;
  6.     get fullName(): string {
  7.         return this._fullName;
  8.     }
  10.     set fullName(newName: string) {
  11.         if (passcode && passcode == "secret passcode") {
  12.             this._fullName = newName;
  13.         }
  14.         else {
  15.             console.log("Error: Unauthorized update of employee!");
  16.         }
  17.     }
  18. }
  20. let employee = new Employee();
  21. employee.fullName = "Bob Smith";
  22. if (employee.fullName) {
  23.     alert(employee.fullName);
  24. }

static

到目前为止，我们只讨论了类的实例成员，那些仅当类被实例化的时候才会被初始化的属性。 我们也可以创建类的静态成员，这些属性存在于类本身上面而不是类的实例上。 

  1. class Router {
  2.     static baseRoute = '/basePath';
  3.     calculateRoute(path: string) {
  4.         return this.baseRoute + this.commonPrefix  + path;
  5.     }
  6.     constructor (public commonPrefix: number) { }
  7. }
  9. let route1 = new Router('/api');  // 一级路径为/api
  10. let route2 = new Router('/page');  // 一级路径为/page
  12. console.log(route1.calculateRoute('/main');  // 最终路径/basePath/api/main
  13. console.log(route2.calculateRoute('/user');  // 最终路径/basePath/page/user

abstract

抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。

  1. abstract class Animal {
  2.     abstract makeSound(): void;
  3.     move(): void {
  4.         console.log('roaming the earch...');
  5.     }
  6. }

下一步