从 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.`);
}
}在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"; // ErrorTypeScript 支持通过 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 关键字并且可以包含访问修饰符。
沪公网安备 31011702000469号