TypeScript基础学习(4): 类

es5的方法

最简单的类

 function Person() {
   this.name = 'zy'
   this.age = 27
      this.run = function () {
     console.log( `${this.name} is run`)  // zy is run
   }
 }
 let person = new Person()
 person.sex = 'female'
 console.log('person.name', person.name) // zy
 console.log('person.sex', person.sex) // female

原型链里面增加属性和方法

   Person.prototype.grade = '一年级'
   Person.prototype.work = function () {
     console.log( `${this.name} is work`)  // zy is work
   }
  console.log('person.grade', person.grade) // 一年级
  person.work()

添加静态方法

  Person.getInfo = function () {
      console.log('person.getInfo') // person.getInfo
    }
  Person.getInfo()

继承

1. 对象冒充继承方式，只能继承【构造函数】里的属性和方法
  function Web () {
    Person.call(this) // 
  }
  let web = new Web()
  console.log('Web.name', web.name) //  zy
  console.log('Web.grade', web.grade) // undefined

2. 原型链继承方式，能继承【构造函数】和【原型链】上的属性和方法
   不能传参调用
  function Web () {
  }
  Web.prototype =  new Person()
  let web = new Web()
  console.log('Web.name', web.name) // zy
  console.log('Web.grade', web.grade) // 一年级
3. 对象冒充 + 原型链继承方式
 function Person(name, age) {
      this.name = name
      this.age = age
      this.run = function () {
      console.log( `${this.name} is run`)  // zy is run
      }
    }
    function Web(name, age) { 
      Person.call(this, name, age) // 继承构造函数的属性和方法
    }
    Web.prototype = Person.prototype // 继承原型链的属性和方法
    let web = new Web('zy', 27)
    web.run()

es6的方法

最基础的类

class Person {
    name: string; // 属性，前面省略了public关键字
    constructor (n:string) { // 构造函数，实例化类的时候触发的函数
        this.name = n
    } 
    run ():void {
        console.log(`${this.name} is run`) // zy is run
    }
} 
let person = new Person('zy')
person.run()

继承

class Person {
    name: string; // 属性，前面省略了public关键字
    constructor (name:string) { // 构造函数，实例化类的时候触发的函数
        this.name = name
    } 
    run ():void {
        console.log(`${this.name} is run`) // ying is run
    }
} 


class Web extends  Person{
    constructor (name:string) {
        super(name) // 初始化父类的构造函数
    }
}
let web = new Web('ying')
web.run()

类里面的修饰符

public 公有 在类里面、子类、类外面都可以访问
protected 保护类型 在类里面、子类里面可以访问，在类外部没法访问
privated 私有 在类里面可以访问 子类、类外面不可以访问

静态属性、静态方法

class Web extends  Person{ 
    static age:number = 20;
    constructor (name:string) {
        super(name) // 实例化父类的时候触发的函数
    }
    static print () { // 静态方法 里面没法直接调用类里面的属性,只能调用静态属性
        console.log(`${this.age} is print`)
    }

}
Web.print() // 类名直接调用

多态

个人理解：重写父类方法，父类方法不写具体的实现，由子类来实现具体功能，不同的子类有不同的表现

抽象类

提供其他类继承的基类，不能直接被实例化
用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现
abstract抽象方法只能放在抽象类中
抽象类和抽象方法用来定义标准 标准：Animal这个类要求它的子类必须包含eat方法

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

class Cat extends Animal {
    constructor (name:string) {
        super(name)
    }
    // 抽象类的子类必须实现抽象类中的抽象方法
    eat() {
        console.log(`${this.name} is cat`) // ying is cat
    }
}
let cat = new Cat('ying')
cat.eat()