ts中的类

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

1、ES6中类的主要用法：

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

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

三、使用 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();

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

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

二、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);

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

一、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) // 不可访问

二、readonly只读属性关键字，只容许出如今属性声明或索引签名中

三、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());