类

关键字 class

class Greeter {
  greetering: string;
  constructor(message: string){
    this.greetering = message;
  }
  // 在使用任何类成员是都使用this关键字
  greet() {
    return 'Hello, ' + this.greetering;
  }
}
let greeter = new Greeter('world');

继承

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

• 类从基类中继承了属性和方法
• 派生类手动包含构造函数时，必须调用super(),他会执行基类的构造函数，在构造函数里访问this的属性之前，必须要先调用super()，这是TS强制执行的重要规则

// 基类或者超类
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');
// 即使定义成Animal类型，但是他的值是House，所以调用move时，会调用Horse里重写的方法
let tom: Animal = new Horse('Tommy the Palomino');

sam.move();
tom.move(34);

成员修饰符

• public：定义类成员时如果不加修饰符那么默认为public，可以随意访问类中定义的成员
• private：不能在声明他的类的外部访问
• protected：与private相似，但是protected成员在派生类(子类)中仍然可以访问
• readonly：将属性设置为只读的，只读属性必须在声明时或构造函数里被初始化

// public 类型 
class Person2 {
  public name: string;
  public constructor(theName: string){
    this.name = theName;
  }
  public move(distanceInMeters: number){
    console.log(`${this.name} moved ${distanceInMeters}m.`);
  }
}

// private类型
class Person1 {
  private name: string;
  constructor(theName: string) {
    this.name = theName;
  }
}
let person = new Person1("Book");
person.name; // error name是私有的访问不到

// protected类型
class Person {
  protected name: string;
  constructor(name: string){
    this.name = name;
  }
}
class Employ 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 Employ('Howard', 'Sales');
console.log(howard.getElevatorPitch());
console.log(howard.name) // error protected 类型外部无法访问

// 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 = 'Ald'; // error name属性是只读的
console.log(dad.name)

注：构造函数也可以被标记为protected，意味着这个类不能在包含他的类外被实例化，但能被继承

// 构造函数也可以被标记为protected，意味着这个类不能在包含他的类外被实例化，但能被继承
class Person3 {
  protected name: string;
  protected constructor(theName: string){
    this.name = theName;
  }
}
class Employee3 extends Person3{
  private department: string;
  constructor(name: string, department: string){
    super(name);
    this.department = department;
  }
  public getElement(){
    return `Hello, my name is ${this.name} and I work in ${this.department}.`;
  }
}
let hward = new Employee3('Howrl',"Sales");
let john = new Person3('John'); // error Person3的构造函数是被保护的

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

class Animal1 {
  private name: string;
  constructor(theName: string) {
    this.name = theName;
  }
}
class Rhino extends Animal1 {
  constructor(){
    super('Rhino');
  }
}
class Employee {
  private name: string;
  constructor(theName: string) {
    this.name = theName;
  }
}
let animal = new Animal1('Goat');
let rhino = new Rhino();
let employee = new Employee('Bob');
// animal跟rhino共同继承自基类Animal1 所以出处是一样的，所以类型是兼容的
animal = rhino;
// employee是独立的虽然字段一样，但是出处不同，所以TS会认为类型不兼容
animal = employee; // error animal 与 employee不兼容

特殊：当比较带有private或protected成员的类型的时候，如果其中一个类型里包含一个private成员，那么只有当另外一个类型中也存在这样一个private成员，并且他们都来自同一处声明时，才认为这两个类是兼容的，protected同样适用

参数属性

可以方便的在一个地方定义并初始化一个成员
定义：参数属性通过给构造函数参数前面添加一个访问限定符来声明，使用private限定一个参数属性会声明并初始化成一个私有成员，public，protected类似

class Octopus1 {
  readonly numberOfLegs: number = 8;
  // 直接在构造函数中创建跟初始化name成员，把声明跟赋值合并
  constructor(readonly name: string){}
}

存取器

TS通过getters/setters来截取对对象成员的访问，可以有效控制对象成员访问
注意：

• 存取器支持ES5或者更高版本
• 只有带get不带set的存取器自动被推断为readonly

let passcode = 'secret passcode';
class Employee4{
  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 employee4 = new Employee4();
employee4.fullName = 'Bob Smith';
if(employee4.fullName){
  console.log(employee4.fullName);
}

静态属性

类实例成员：只有在类被实例化的时候才会被初始化，并且通过this.访问实例成员

静态属性：属性存在于类本身上而不是实例上，使用static关键字定义，通过构造函数名.来访问静态成员

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}));

抽象类

作为其他派生类的基类使用，一般不会被实例化
注：不同于接口，抽象类可以包含成员的实现细节
关键字：abstract关键字用来定义抽象类或者抽象类内部的抽象方法

抽象类特征：

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

// 定义
abstract class Animal4{
  abstract makeSound(): void;
  move(): void {
    console.log('roaming the earch...');
  }
}

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 Auditiing'); // 派生类构造函数必须调用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(); // error 不能创建一个抽象类型的实例
departMent = new AccountingDepartment(); // 允许对一个抽象类子类进行实例化跟赋值
departMent.printName();
departMent.printMeeting();
// departMent.generateReports(); // error 方法在声明的抽象类中不存在

构造函数

当在TS中声明了一个类时，实际上同时声明了很多东西：

• 实例的类型
• 创建了一个构造函数，构造函数会在使用new创建类实例的时候被调用，这个构造函数也包含了类的所有静态属性

class Greeter1 {
  greeting: string;
  constructor(message: string){
    this.greeting = message;
  }
  greet() {
    return 'Hello, ' + this.greeting;
  }
}
// Greeter1类的实例的类型是Greeter1
let greete: Greeter1;
greete = new Greeter1('world');
console.log(greete.greet());

把类当做接口使用：
因为类定义会创建两个东西：类的实例类型、一个构造函数
因为类可以创建类型，所以能够在允许使用接口的地方使用类

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