TypeScript9(Class类)

ES6提供了更接近传统语言的写法，引入了Class（类）这个概念，作为对象的模板。通过class关

键字，可以定义类。基本上，ES6的class可以看作只是一个语法糖，它的绝大部分功能，ES5都可

以做到，新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。上面的

代码用ES6的“类”改写，就是下面这样。

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

TS中如何定义类

在TypeScript是不允许直接在constructor中 定义变量的 需要在constructor之前先声明

 class Person {
    name:string
    age:number
    sub:boolean
    constructor(name:string, age:number, sub:boolean) {
    this.name = name
    this.age = age
    this.sub = sub
   }

   run() {
     return '789'
   }

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

 class Person {
    name:string
    //constrnctor中未使用name，此处给了默认值
    age:number = 0
    sub:boolean
    constructor(name:string, age:number, sub:boolean) {
    this.name = name
    this.sub = sub
   }

   run() {
     return '789'
   }

类的修饰符

类的修饰符共三个：分别为：public  private  protected

class Person {
  // 默认是public(公共的)，在person类的内部和外部都可以访问
  public name:string
  // private:私有的，私有变量只能在内部访问,只能在person类中进行访问
  private age:number
  // person类的内部和子类中可以访问
  protected sub:boolean 
  constructor(name:string, age:number, sub:boolean) {
    this.name = name
    this.age = age
    this.sub = sub
  }

  run() {
    return '789'
  }

}

let p = new Person('小剑', 18, false)
p.name

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

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

class Person {
  // 默认是public(公共的)，在person类的内部和外部都可以访问
  public name:string
  // private:私有的，私有变量只能在内部访问,只能在person类中进行访问
  private age:number
  // person类的内部和子类中可以访问
  protected sub:boolean 
  constructor(name:string, age:number, sub:boolean) {
    this.name = name
    this.age = age
    this.sub = sub
  }

  run() {
    return '789'
  }

}

let p = new Person('小剑', 18, false)
p.name // 正常
p.age // 报错，只能在Person类中访问
p.sub // 报错，只能在Person类及其子类中访问

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

class Person {
  // 默认是public(公共的)，在person类的内部和外部都可以访问
  public name:string
  // private:私有的，私有变量只能在内部访问,只能在person类中进行访问
  private age:number
  // person类的内部和子类中可以访问
  protected sub:boolean
  constructor(name:string, age:number, sub:boolean) {
    this.name = name
    this.age = age
    this.sub = sub
  }

  run() {
    return '789'
  }

}


class Man extends Person{
  constructor(){
    super('小剑', 19, true)
    console.log(this.sub)
  }
  dev(){
     console.log(this.sub)
    }
}

let p =new Person('小剑', 18, true)
let man = new Man()

static 静态属性 和 静态方法

注意：静态函数和内部变量是互斥的，即在静态函数中不能通过this访问内部变量；

在constructor中也不能通过this访问静态函数,但是可以通过Person.静态函数访问；

在Class类的外部访问静态函数或者是静态属性，无需通过new实例化对象，直接通过类名.静态属

性/静态方法， 如：Person.aaa    Person.run()

class Person {
  // 默认是public(公共的)，在person类的内部和外部都可以访问
  public name:string
  // private:私有的，私有变量只能在内部访问,只能在person类中进行访问
  private age:number
  // person类的内部和子类中可以访问
  protected sub:boolean
  // static定义静态属性或者是静态方法，定义的时候不能通过
  // this访问,都是通过类名进行访问
  static aaa:string = '123' 
  constructor(name:string, age:number, sub:boolean) {
    this.name = name
    this.age = age
    this.sub = sub
    Person.dev()
  }

  static run() {
    // 类中的静态函数不能通过this访问类中的变量
    // 注意：静态函数和内部变量是互斥的，即在静态函数中不能通过this访问内部变量
    // 在constructor中也不能通过this访问静态函数,但是可以通过Person.静态函数访问
    // this.name
    return '789'
  }

  static dev() {
    // 在静态函数中可以通过this调用类中定义的静态资源
    this.aaa
    this.run()
    return 'qqqqqqqqqqq'
  }
}

class Man extends Person{
  constructor(){
    super('小剑', 19, true)
    this.name
  }
}

let p =new Person('小剑', 18, true)
// 静态属性和静态函数不需要通过new实例化进行访问，可以直接通过类名.属性进行访问
console.log(Person.aaa);
console.log(Person.run());

interface 定义类

ts interface 定义类 使用关键字 implements   后面跟interface的名字多个用逗号隔开 继承还是用

extends

interface Person {
  run(type: boolean):boolean 
}
interface H {
  set(): void
}

class A {
  params: string
  constructor(params:string) {
    this.params = params
  }
}
class Man extends A implements Person, H{
  run(type: boolean):boolean{
    return type
  }
  set(){}
}

抽象类

应用场景如下：

情况一：如果你写的类实例化之后毫无用处此时我可以把他定义为抽象类；

情况二：也可以把他作为一个基类-> 通过继承一个派生类去实现基类的一些方法；

情况一代码说明：下面这段代码会报错抽象类无法被实例化

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

情况二代码说明：

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

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

abstract class A {
   name: string
   constructor(name: string) {
      this.name = name;
   }
   print(): string {
      return this.name
   }
 
   abstract getName(): string
}
 
class B extends A {
   constructor() {
      super('小剑')
   }
   getName(): string {
      return this.name
   }
}
 
let b = new B();
 
console.log(b.getName());