TS中的类实现

类的基本使用

定义
TypeScript 是面向对象的 JavaScript。类描述了所创建的对象共同的属性和方法。TypeScript 支持面向对象的所有特性，比如 类、接口等。
类的内容如下：

• 字段 − 字段是类里面声明的变量。字段表示对象的有关数据。
• 构造函数 − 类实例化时调用，可以为类的对象分配内存。
• 方法 − 方法为对象要执行的操作

class Person {
  // 需要先定义实例属性，才能够使用
  name: string;
  age: number;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
  say(): void {
    console.log("hello world");
  }
}

let person = new Person("张三", 1);
person.say();

类的继承

TypeScript 支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类。

类继承使用关键字 extends，子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。

TypeScript 一次只能继承一个类，不支持继承多个类，但 TypeScript 支持多重继承（A 继承 B，B 继承 C）。

语法格式如下：class child_class_name extends parent_class_name

class Person {
  // 需要先定义实例属性，才能够使用
  name: string;
  age: number;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
  say(): void {
    console.log("hello world");
  }
}

class Student extends Person {
  ID: number;
  constructor(name: string, age: number, ID: number) {
    super(name, age);
    this.ID = ID;
  }
  say(): void {
    super.say();
    console.log("重写后的方法");
  }
}

let stu = new Student("张三", 1, 111);
stu.say();

static

static 关键字用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用。

class Person {
  static phone: number = 111111;
  static play(): void {
    console.log(`phone: ${Person.phone}`);
  }
}
Person.play();

类中的修饰符

• public(默认)：公有，可以在任何地方被访问
• protected: 受保护，可以被其自身以及其子类访问
• private: 私有，只能被其定义所在的类访问。
• readonly: 可以使用 readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化

class Person {
  public name: string;
  protected age: number;
  private sex: string;

  constructor(name: string, age: number, sex: string) {
    this.name = name;
    this.age = age;
    this.sex = sex;
  }
  say(): void {
    console.log("hello world");
  }
}

getter和setter

官方的另外一个名字: 存取器
通过getters/setters来截取对对象成员的访问

如果存在 get ，但没有 set ，则该属性自动是只读的
如果没有指定 setter 参数的类型，它将从 getter 的返回类型中推断出来
访问器和设置器必须有相同的成员可见性

class Person {
  private _name: string = "哈哈";

  get name(): string {
    console.log("get方法");
    return this._name;
  }

  set name(name: string) {
    console.log("set方法");
    this._name = name;
  }
}

let person = new Person();

person.name = "张三";
console.log(person);
console.log(person.name);

抽象类

• 定义
  抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化
  抽象类是专门用于定义哪些不希望被外界直接创建的类的
  抽象类和接口一样用于约束子类

• 抽象类和接口区别
  抽象方法必须包含 abstract关键字并且可以包含访问修饰符
  接口中只能定义约束, 不能定义具体实现。而抽象类中既可以定义约束, 又可以定义具体实现

abstract class Person {
  abstract name: string;
  abstract show(): string;

  showName() {
    console.log(this.show());
  }
}

class Student extends Person {
  name: string = "张三";
  show(): string {
    return "李四";
  }
}

let s = new Student();
console.log(s.show());

implements

• 类可以实现接口，使用关键字 implements
• 可以使用一个 implements 子句来检查一个类，是否满足了一个特定的接口。如果一个类不能正确地实现它，就会发出一个错误

实现一个带有可选属性的接口并不能创建该属性
只要一个接口继承了某个类, 那么就会继承这个类中所有的属性和方法,但是只会继承属性和方法的声明, 不会继承属 性和方法实现

与extends的区别​

extends: 继承某个类，继承之后可以使用父类的方法，也可以重写父类的方法
implements:实现某个接口，必须重写才可以使用

interface IInfo {
  location: string;
}
interface ISchool {
  schoolName: String;
}

class Student implements IInfo, ISchool {
  schoolName: String = "中山大学";
  location: string = "广州";
}