什么是JavaScript中的类
对JavaScript中的类还不了解的，请查看“JavaScript中的类”。
TypeScript中的类
TypeScript在JavaScript中的类基础上，新添了一些内容，并不是JavaScript中关于新内容，只是在TypeScript中给了我们新的语法，最后都是编译成JavaScript。
公共，私有与受保护的修饰符
在TypeScript中我们可以使用一些访问修饰符来约束类的成员。
public
在TypeScript里，成员都默认为 public。你也可以明确的将一个成员标记成 public。
class Animal {
public name: string;
public constructor(name: string) {
this.name = name; }
public move(distanceInMeters: number) {
console.log(`${
this.name} moved ${
distanceInMeters}m.`);
}
}
// 下面代码和面等价
class Animal {
name: string;
constructor(name: string) {
this.name = name; }
move(distanceInMeters: number) {
console.log(`${
this.name} moved ${
distanceInMeters}m.`);
}
}
类的成员加上public访问修饰符，那么类，类的实例，类的子类都可以访问对应的成员。
class Animal {
public name: string;
public constructor(name: string) {
this.name = name; }
public move(distanceInMeters: number) {
console.log(`${
this.name} moved ${
distanceInMeters}m.`);
}
}
class Dog extends Animal {
constructor(name: string) {
super(name)
}
}
const animal = new Animal('animal');
console.log(animal.name); // 可访问
const dog = new Dog('dog');
console.log(dog.name); // 可访问
private
当成员被标记成 private时，它就不能在声明它的类的外部访问。比如：
class Animal {
private name: string;
constructor(theName: string) {
this.name = theName; }
}
new Animal("Cat").name; // 错误: 'name' 是私有的.
类的成员加上private访问修饰符，那么只有类可以访问对应的成员。一般用以定义类的私有静态属性。
protected
protected修饰符与 private修饰符的行为很相似，但有一点不同， protected成员在派生类中仍然可以访问。例如：
class Person {
protected name: string;
constructor(name: string) {
this.name = name; }
}
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");
console.log(howard.getElevatorPitch());
console.log(howard.name); // 错误
let person = new Person("render");
console.log(person.name); // 错误
类的成员加上private访问修饰符，那么只有类及其子类可以访问对应的成员。
构造函数也可以被标记成 protected。 这意味着这个类不能在包含它的类外被实例化，但是能被继承。比如：
class Person {
protected name: string;
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' 的构造函数是被保护的.
下面是三个访问修饰符可访问性的总结。
readonly修饰符
你可以使用 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"; // 错误! name 是只读的.
参数属性
构造器是可选的，并不是一定要有构造器。
class Animal {
}
const animal = new Animal()
构造器可以用来初始化成员变量：
class Animal {
name: string;
constructor(name: string) {
this.name = name;
}
}
const animal = new Animal("animal");
console.log(animal.name);
这是一种普遍的形式，TypeScript还支持简写形式，需要在成员中添加一个访问修饰符，它会自动在上声明，并且从构造器中复制过去。
class Animal {
constructor(public name: string) {
}
}
const animal = new Animal("animal");
console.log(animal.name);
抽象类
抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。
abstract class Animal {
abstract makeSound(): void;
move(): void {
console.log('roaming the earch...');
}
}
const animal = new Animal(); // error 无法创建抽象类的实例。
抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体。 然而，抽象方法必须包含 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(); // 错误: 方法在声明的抽象类中不存在
把类当做接口使用
类定义会创建两个东西：类的实例类型和一个构造函数。 因为类可以创建出类型，所以你能够在允许使用接口的地方使用类。
class Point {
x: number;
y: number;
}
interface Point3d extends Point {
z: number;
}
let point3d: Point3d = {
x: 1, y: 2, z: 3};