2.4-类类型

Create by fall on 2021-11-17 Recently revised in 2022-02-15

类

类的继承

如果 a 继承了 A 类的内容，a 称为子类，A 称为基类

子类也叫派生类，基类也叫父类

class Hero {
  // 类的属性
  name:string
  heroName:string
  activeTime:number
  // 类的构造方法
  constructor(name:string= '小汉堡',heroName:string = '铁血汉堡',activeTime:number = 2){
    this.name = name
    this.heroName = heroName
    this.activeTime = activeTime
  }
  // 类的实例方法
  heroInfo(str:string){
    console.log(`我是一名兴趣使然的英雄，我叫${this.name},我的英雄名是${this.heroName},我已经活跃了${this.activeTime}年`)
    console.log('一句话描述自己：'+str)
  }
}
// 继承类的方法
class SuperHero extends Hero{
  constructor(name:string,heroName:string,activeTime:number){
    super(name,heroName,activeTime)
  }
  // 这里可以调用父亲的
  sayHi(){
    super.heroInfo('我懒得描述')
  }
}
let he = new Hero()
he.heroInfo('汉堡，我只服自己')
let jienuosi = new SuperHero('杰诺斯',"魔鬼改造人",4)
jienuosi.sayHi()
jienuosi.heroInfo("rest in peace my enermy")

类的多态

class Hero {
    name:string
    constructor(name:string='汉堡'){
      this.name = name
    }
    jump(height:number=2){
      console.log(`这个英雄能跳${height}m 高`)
    }
  }
  class SurperHero extends Hero{
    jump(height:number=100){
      console.log(`这个英雄能跳${height}m 高`)
    }
  }
  class OtherHero extends Hero{
    jump(height:number=18){
      console.log(`这个英雄能跳${height}m 高`)
    }
  }
  // let jienuos:SurperHero =new SurperHero
  // let bickHero:OtherHero =new OtherHero
  let jienuos:Hero =new SurperHero // Hero 的子类，都可以用 Hero 进行约束，但是调用的时候是调用的子类方法
  let bickHero:Hero =new OtherHero
  jienuos.jump()
  bickHero.jump()
  function showThem(hero:Hero){
    hero.jump()
  }
  showThem(jienuos)

类的修饰符

类的修饰符，描述类的成员，构造函数，方法的可访问属性

• private 私有修饰符，智能在内部进行访问
• public 默认修饰符，意思是公共修饰符，外部构造方法和成员都可以访问
• protected 保护修饰符，能在子类构造方法中访问，外部无法访问
• readonly 只读修饰符，修饰之后，只能进行读取，不能更改属性名（类的方法内，也是无法修改属性值），构造函数时，可以对属性成员进行修改
• static 声明静态类，智能通过类名进行调用
• abstract 抽象类，一般抽象类作为父类，子类必须实现抽象类中的抽象属性和方法

构造函数时，只要使用修饰符进行修饰，就可以不用添加类的属性

class Hero {
  public heroName:string // 所有成员都有自己默认的修饰符 public 
  // private name:string // 用私有 private 进行限制后，只能在类本身使用
  readonly hobby:string 
  age:number
  constructor(name:string= '汉堡骑士'){
    this.name= name
  }
  jump(num1:number = 10){
    console.log(`我叫${this.heroName}是一个英雄`)
    console.log('一窜就是'+ num1 +'米这么高')
  }
}
let bickKnight = new Hero
bickKnight.heroName = '单车骑士'
bickKnight.jump(0.5)
console.log(bickKnight.hobby)

存取器

setter & getter 存取器可以在用户使用存储功能，或者是调用查找功能时触发。

class Hero {
    name: string
    heroName: string
    constructor(name: string = '汉堡', heroName: string = '蜜汁') {
      this.name = name
      this.heroName = heroName
    }
    get fullName() {
      console.log('loading.....')
      return this.heroName + '_' + this.name 
    }
    set fullName(msg){
      let mm = msg.split("_")
      console.log(mm)
      this.name= mm[1]
      this.heroName= mm[0]
    }
  }
  let mememe = new Hero()
  console.log(mememe.fullName)
  mememe.fullName = ('秃头披风侠_琦玉')
  console.log(mememe.fullName)
  console.log(mememe.name)

static 静态属性

静态属性中自带 name 属性，所以不可以设置 name 为静态属性值，

使用 static 绑定构造方法和构造属性后，只能通过类名进行访问

静态类表明只能通过类名调用，比如 Math.random() 就是静态方法。

class Hero {
  static heroName:string = '汉堡'
  static heroTag(){
    console.log('英雄就是在别人无法面对时挺身而出的人')
  }
}
// cc 此时为实例对象，不能调用静态方法
let cc = new Hero
// console.log(cc.heroName)
// 无法输出 cc.heroName
console.log(Hero.heroName)
Hero.heroName = '秃头披风侠'
console.log(Hero.heroName)
Hero.heroTag()

abstract 抽象类

抽象类不用来进行实现，而是使用继承的类，完成实现

abstract class Hero {
  // 抽象类 : 抽象类的目的是为了子类进行服务的
  // 抽象类中很少使用抽象属性让子类进行呈现
  static jump(){
    console.log('冲冲冲吃好吃')
  }
  abstract eat() // abstract可以有抽象的类，但是不能有具体的实现
}
class SuperHero extends Hero{
  eat(){
    console.log('take it to your month')
  }
  static eat(){
    console.log('suck it')
  }
}
// let qiyu = new Hero() // 无法实例化抽象类
Hero.jump()
SuperHero.eat()
let cc = new SuperHero()
cc.eat()

接口实现类

// 定义一个接口
interface OneHero{
  hero()
}
// 此时接口可以看做 Person 类的一个约束
class Person implements OneHero{
  hero(){
    console.log('只有内心强大的人，才有资格做英雄')
  }
}
let jodge = new Person
jodge.hero()

类可以实现接口，放在 4.3 进行说明

存在的问题

namespace nace {
  export class Foo {}
}
import Bar = nace.Foo;
let bar: Bar; // ok

// class Foo {}
// const Bar = Foo;
// let bar: Bar; // Error