ts中的类

TypeScript 除了实现了所有 ES6 中的类的功能以外，还添加了一些新的用法（部分ES7）。

一、ES6中类的主要用法：

1、使用 class 定义类，使用 constructor 定义构造函数。通过 new 生成新实例的时候，会自动调用构造函数。

2、使用 extends 关键字实现继承，子类中使用 super 关键字来调用父类的构造函数和方法。

3、使用 static 修饰符修饰的方法称为静态方法，它们不需要实例化，而是直接通过类来调用。

类相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用

class Person {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  run = (): string => {
    // 实例方法
    return this.name;
  };
  static print = () => {
    console.log("Persion的静态方法");
  };
}
var p = new Person("testName");
p.run();
Person.print();

二、实现的ES7中类的用法：

1、ES6 中实例的属性只能通过构造函数中的 this.xxx 来定义，ES7 提案中可以直接在类里面定义

2、ES6 中只有静态方法，ES7 提案中，可以使用 static 定义静态属性

class Person {
  name: string;
  static title: string = "类的静态属性";
  constructor(name: string) {
    this.name = name;
  }
  run = (): string => {
    // 实例方法
    return this.name;
  };
  static print = () => {
    console.log("Persion的静态方法");
  };
}
var p = new Person("testName");
p.run();
Person.print();
console.log(Person.title);

三、TypeScript自身实现的类的用法：

1、TypeScript 新增了三种访问修饰符来修饰属性或方法，分别是 public、private 和 protected。

• public （共有）修饰的属性或方法是公有的，可以在任何地方被访问到，默认所有的属性和方法都是 public 的。在类的里边、子类以及类的外边都可以访问

  class Person {
    name: string; //定义属性  前面省略了public关键词
    constructor(n: string) {
      // 构造函数---实例化类的时候出发的方法
      this.name = n;
    }
    run = (): string => {
      return this.name;
    };
  }
  var p = new Person("testName");
  console.log(26, p.name); // 可访问
  console.log(p.run()); // 可调用

• protected（保护） 修饰的属性或方法是受保护的，它和 private 类似，区别是它在子类中也是允许被访问的。在类里边和子类中可以访问，在类外部无法访问

  class Person {
    protected name: string; //定义属性  前面省略了public关键词
    constructor(n: string) {
      // 构造函数---实例化类的时候出发的方法
      this.name = n;
    }
    run = (): string => {
      return this.name; // 可访问
    };
  }
  var p = new Person("testName");
  console.log(p.run()); // 可调用
  
  // 通过extends和super实现继承
  class Web extends Person {
    constructor(name: string) {
      super(name);
      console.log(this.name); // 可访问
    }
  }
  const w = new Web("test");
  // console.log(w.name) //不可访问
  // console.log(p.name) // 不可访问

• private （私有）修饰的属性或方法是私有的，不能在声明它的类的外部访问。在类里边可以访问，子类和类外部无法访问

• class Person {
    private name: string; //定义属性  前面省略了public关键词
    constructor(name: string) {
      // 构造函数---实例化类的时候出发的方法
      this.name = name;
    }
    run = (): string => {
      return this.name; // 可访问
    };
  }
  var p = new Person("testName");
  
  // 通过extends和super实现继承
  class Web extends Person {
    constructor(name: string) {
      super(name);
      // console.log(this.name); // 可访问
    }
  }
  const w = new Web("test");
  // console.log(w.name) //不可访问
  // console.log(p.name) // 不可访问

2、readonly只读属性关键字，只允许出现在属性声明或索引签名中

3、abstract 用于定义抽象类和其中的抽象方法。抽象类是不允许被实例化的；抽象类中的抽象方法必须被子类实现，抽象方法只能放在抽象类中。抽象类和抽象方法用来定义标准,为子类提供一个基类

abstract class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  abstract eat(): string;
}

class Dog extends Animal {
  eat = () => {
    return "狗粮";
  };
}

let dog = new Dog("kittle");
console.log(dog.eat());