TypeScript学习日记三

• 构造函数和this

class Person {
  //实例属性
  name: string = '孙悟空'
  //static 定义静态属性，只能通过Person.name来访问
  static age: number = 18;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
  bark() {
    console.log(this);
  }
}

const per = new Person();
console.log(per);
console.log(per.name,per.age);
console.log(Person.age);

• 继承

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  sayHello() {
    console.log()
  }
}

class Dog extends Animal {
   run() {
      console.log(`${this.name}在跑~~~`)
   }
}

class Cat extends Animal {
   age: number;
   constructor(name: string, age: number) {
     //子类写构造函数，会导致父类构造函数不执行，在子类构造函数中必须要调用父类构造函数,不写继承会出错
     super(name);//调用父类构造函数，才能保证正常继承
     this.age = age;
   }
   sayHello() {
      console.log('覆盖父类的sayHello方法')
      super.sayHello();//会调用父类sayHello()方法
   }
   
}

• 抽象类

//禁止类用来创建对象
//以abstract创建的类叫创建类，专门用来被继承的类
abstract class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  abstract sayHello():void;
  //定义一个抽象方法
  //抽象方法使用abstract开头，没有方法体
  //抽象方法只能定义在抽象类中,子类必须对抽象方法进行重写
}

class Dog extends Animal {
   run() {
      console.log(`${this.name}在跑~~~`)
   }
}

class Cat extends Animal {
   age: number;
   constructor(name: string, age: number) {
     //子类写构造函数，会导致父类构造函数不执行，在子类构造函数中必须要调用父类构造函数,不写继承会出错
     super(name);//调用父类构造函数，才能保证正常继承
     this.age = age;
   }
   sayHello() {
      console.log('覆盖父类的sayHello方法')
      super.sayHello();//会调用父类sayHello()方法
   }
   
}

• 接口 interface

  type myType = {
    name: string;
    age: number;
  }
  //类不能重复定义,接口可以，且属性可以叠加
  interface myInterface {
    name: string;
    age: number;
  }
  //接口只定义对象的结构，而不考虑实际值
  //在接口中所有的方法都是抽象方法
  interface myInterface {
    sex: string;
    sayHello():void;
  }
  
  //实现接口就是让类去满足接口的要求
  class MyClass implements myInter {
    name: string;
    constructor(name: string) {
      this.name = name;
    }
    sayHello(): void {
    
    }
  }

• 接口和抽象类的区别

  抽象类有实例方法和抽象方法
  接口只有抽象方法，只用于实现

• 属性的封装

  ...
  public name: string //可以在外部访问
  private age: number //只可以在当前类使用
  //可以通过访问方法来获取属性值
  getAge() {
     return this.age
  }
  setAge(value: number) {
     this.age = value
  }
  protected num: number //只能在类中访问
  ...

• 简单语法

  constructor(public name: string,public age: number) { }
  等价于:
  name: string;
  age: number;
  constructor(name: string, age: number) {
     this.name = name;
     this.age = age
  }
  

• 泛型

  function fn<T>(a:T): T {
    return a;
  }
  fn(10) //T是number
  fn<string>('hello')  //指定泛型
  
  function fk<T,K>(a:T,b:k):T{
    console.log(b);
    return a;
  }//指定多个泛型
  fk<number,string>(123,'hello')//多个类型推断
  
  interface Inter{
    length: number;
  }
  //泛型T必须是Inter的实现类
  function fn3<T extends Inter>(a: T): number {
    return a.length
  }
  fn3('123')  //传的参数要满足Inter接口,要有length属性,'123'有length属性，通过
  
  class MyClass<T> {
    name: T;
    constructor(name: T) {
      this.name = name;
    }
  }
  const mc = new MyClass<string>('孙悟空');