LayaBox---TypeScript---类

1.普通类的示例

2.继承

3.公共、私有与受保护的修饰符

public:

private:

protected:

4.readonly修饰符

5.存取器

6.静态属性--static

7.抽象类--abstract

8.把类当作接口使用

1.普通类的示例

class Greeter{greeting: string;constructor(msg: string){this.greeting = msg;}greet(){return "hello, " + this.greeting;}
}let greeter = new Greeter("world");

2.继承

//一个简单的继承示例
class Animal{move( distanceInMeters: number=0 ){console.log('Animal moved ${distanceInMeters}m.');}
}class Dog extends Animal{bark(){console.log( 'Woof! Woof!' );}
}Const dog = new Dog();
dog.bark();
dog.move(10);
dog.bark();

//一个复杂的继承示例
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);

与前一个简单的继承示例不同的是，它的派生类包含了一个构造函数，它必须调用super(),它会执行基类的构造函数。

⚠️注意：在构造函数里访问this的属性前，一定要调用supper()。这是ts强制执行的一条规则。

3.公共、私有与受保护的修饰符

3.1 与C#等语言不同，ts里成员默认都是public属性

public:

//也可以明确的将成员标记成public
class Animal {public name: string;public constructor(theName: string) { this.name = theName; }public move(distanceInMeters: number) {console.log(`${this.name} moved ${distanceInMeters}m.`);}
}

private:

//当成员被标记成 private 时，它就不能在声明它的类的外部访问
class Animal {private name: string;constructor(theName: string) { this.name = theName; }
}new Animal("Cat").name; // 错误: 'name' 是私有的.

TypeScript使用的是结构性类型系统。当我们比较两种不同的类型时，并不在乎它们从何处而来，如果所有成员的类型都是兼容的，我们就认为它们的类型是兼容的。

然而，当我们比较带有 private或 protected成员的类型的时候，情况就不同了。如果其中一个类型里包含一个 private成员，那么只有当另外一个类型中也存在这样一个 private成员，并且它们都是来自同一处声明时，我们才认为这两个类型是兼容的。对于 protected成员也使用这个规则。

class Animal {private name: string;constructor(theName: string) { this.name = theName; }
}class Rhino extends Animal {constructor() { super("Rhino"); }
}class Employee {private name: string;constructor(theName: string) { this.name = theName; }
}let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");animal = rhino;
animal = employee; // 错误: Animal 与 Employee 不兼容.

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); // 错误注意，我们不能在 Person类外使用 name，但是我们仍然可以通过 Employee类的实例方法访问，因为 Employee是由 Person派生而来的。

构造函数也可以被标记成 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' 的构造函数是被保护的.

4.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 是只读的.

上面的例子，我们在Octopus里定义了一个只读成员name和一个参数为theName的构造函数，且将theName的值赋给了name。

而参数属性可以方便的让我们在一个地方定义并初始化成员。

class Octopus {readonly numberOfLegs: number = 8;constructor(readonly name: string) {}
}

如上，我们是如何舍弃了 theName，仅在构造函数里使用 readonly name: string参数来创建和初始化 name成员。我们把声明和赋值合并至一处。

5.存取器

TypeScript支持通过getters/setters来截取对对象成员的访问。

class Employee {fullName: string;
}let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {console.log(employee.fullName);
}

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

let passcode = "secret passcode";class Employee {private _fullName: string;get fullName(): string {return this._fullName;}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";
if (employee.fullName) {alert(employee.fullName);
}

⚠️注意：

1.存取器要求你将编译器设置为输出ECMAScript 5或更高。不支持降级到ECMAScript 3。

2.只带有 get不带有 set的存取器自动被推断为 readonly。

6.静态属性--static

我们使用 static定义 origin，因为它是所有网格都会用到的属性。每个实例想要访问这个属性的时候，都要在 origin前面加上类名。如同在实例属性上使用 this.前缀来访问属性一样

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

7.抽象类--abstract

抽象类做为其它派生类的基类使用。它们一般不会直接被实例化。

1.不同于接口，抽象类可以包含成员的实现细节。

abstract class Animal {abstract makeSound(): void;move(): void {console.log('roaming the earch...');}
}

2.抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。

3.抽象方法必须包含 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(); // 错误: 方法在声明的抽象类中不存在

8.把类当作接口使用

class Point {x: number;y: number;
}interface Point3d extends Point {z: number;
}let point3d: Point3d = {x: 1, y: 2, z: 3};