学习TypeScript 8（Class类）

ES6提供了更接近传统语言的写法，引入了Class（类）这个概念，作为对象的模板。通过class关键字，可以定义类。基本上，ES6的class可以看作只是一个语法糖，它的绝大部分功能，ES5都可以做到，新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。上面的代码用ES6的“类”改写，就是下面这样。

 //定义类
 class Person {
  constructor () {
 ​
  }
  run () {
 ​
  }
 }

TS中定义类

 // TS中声明一个类
 class Person {
  name:string
  age:number
  sub:boolean
  //constructor 是构造函数
  constructor (name:string,age:number,sub:boolean) {
      this.name = name
      this.age = age
      this.sub = sub
  }
 }
 ​
 new Person("龙龙龙",20,true)
 ​

在TypeScript是不允许直接在constructor 定义变量的 需要在constructor上面先声明

如果了定义了变量不用 也会报错 通常是给个默认值 或者 进行赋值

类的修饰符 public private protected

Public

使用public 修饰符 可以让你定义的变量 内部访问 也可以外部访问 如果不写默认就是public

 class Person {
  public name:string  //定义为 public类型
  //未说明类型则默认为 punlic类型
  private age:number //定义为 private类型
  protected sub:boolean  //定义为protected类型
  //constructor 是构造函数
  constructor (name:string,age:number,sub:boolean) {
      this.name = name
      this.age = age
      this.sub = sub
  }
 }
 ​
 let p =  new Person("龙龙龙",20,true)
 //类的修饰符 public private protected
 p.name  //  public 类型 在外部也可以访问 

private

使用 private 修饰符 代表定义的变量私有的只能在内部访问 不能在外部访问

 p.age   //报错  private 类型 代表定义的变量私有的只能在内部访问 不能在外部访问

protected

使用 protected 修饰符 代表定义的变量私有的只能在内部和继承的子类中访问 不能在外部访问

 class Man extends Person{
  constructor () {
      super("张三",18,false)
      console.log(this.sub)
  }
  create () {
     console.log(this.sub)
  }
 }
 let xiaoman = new Person('小满',18,true)
 let man = new Man()
 man.sub //报错 使用 protected 修饰符 代表定义的变量私有的只能在内部和继承的子类中访问 不能在外部访问
 ​

static 静态属性和静态方法

我们用static 定义的属性 不可以通过this 去访问 只能通过类名去调用

 //静态属性和静态方法
 class Car {
  name:string
  price:number
  static aaa:string = '123456'    //静态属性
  constructor(name:string,price:number,aaa:string) {
      this.name = name
      this.price = price
      // this.aaa = aaa  // 报错 静态变量不能使用this进行访问， 需要使用类名才能访问
      Car.aaa = aaa
      // this.run()  // 报错 构造函数中也不能使用this调用静态方法
      // Car.run()   //这种可以
  }
  print(){
      console.log(this.name)
      console.log(this.price)
      // console.log(this.aaa)   //报错
      console.log(Car.aaa)
  }
  static run() {  //静态方法
      // this.name    静态方法只能访问静态变量
      // this.dev()   可以的 静态方法可以相互调用
      // this.print() 报错 静态方法中调用普通方法不能使用this
      // print()  可以调用普通方法
      return '789'
 ​
  }
  static dev() {
      return 'dev'
  }
 }
 let c = new Car('宝马',9999,'666666') // 此时静态变量 aaa已经被修改
 console.log(c.name + c.price)   //非静态变量需要 new成对象后才能访问
 c.print()   //非静态方法 需要new成对象才能进行调用
 console.log(Car.aaa)    //静态变量可以使用类名直接访问 不需要new
 //输出666666
 console.log(Car.run())    //静态方法也是可以直接使用类名进行调用

注意，静态变量可被所有对象共同访问，会被修改

interface 定义类 主要起约束作用

 //interface 定义类
 //跟 Java一样
 interface Home {
  run(type:boolean):boolean
 }
 interface H {
  set():void
 }
 ​
 class A {
  params:string
  constructor(params:string){
      this.params = params
  }
 }
 ​
 class Jia extends A  implements Home,H {    //类可以同时继承父类和实现接口
  //类实现接口
  //不实现会报错  起到了对类的约束作用
  run(type: boolean): boolean {
      return type
  }
  set(): void {
 ​
  }
  constructor(){
      super('继承父类')
  }
 }

抽象类

应用场景如果你写的类实例化之后毫无用处此时我可以把他定义为抽象类

或者你也可以把他作为一个基类-> 通过继承一个派生类去实现基类的一些方法

例子：

下面这段代码会报错抽象类无法被实例化

 abstract class AA {
  public name:string
 }
 new AA()

例子2：

我们在A类定义了 getName 抽象方法但未实现

我们B类实现了A定义的抽象方法 如不实现就不报错 我们定义的抽象方法必须在派生类实现

abstract class AAA {
 name: string
 constructor(name: string) {
    this.name = name;
 }
 print(): string {
    return this.name
 }

 abstract getName(): string
}

class BBB extends AAA {
 constructor() {
    super('龙龙龙')
 }
 // getName(): string {  //不实现父类的抽象方法就会报错
 //     return this.name
 //  }
}

let b = new BBB();

console.log(b.getName());