typescript---接口

1.接口一方面可以在面向对象编程中表示为行为的抽象，另外可以用来描述对象的形状;
2.接口就是把一些类中共有的属性和方法抽象出来,可以用来约束实现此接口的类
3.一个类可以继承另一个类并实现多个接口
4.接口像插件一样是用来增强类的，而抽象类是具体类的抽象概念
5.一个类可以实现多个接口，一个接口也可以被多个类实现，但一个类的可以有多个子类，但只能有一个父类

接口

interface中可以用分号或者逗号分割每一项，也可以什么都不加
1.1 对象的形状

interface Speakable {
    speak(): void;
    name?: string;
    [propName: string]: any  //这句话的意思是，可以有其他的任何属性
}
let speakMan: Speakable = {
    speak():void {
    },
    name: "aaa",
    age: 18
 }

1.2 行为的抽象

//接口可以在面向对象编程中表示为行为的抽象
interface Speakable{
    speak():void;
}
interface Eatable{
    eat():void
}
//一个类可以实现多个接口
class Person implements Speakable,Eatable{  //可以实现多个接口
    speak(){
        console.log('Person说话');
    }
    eat(){}
}
class TangDuck implements Speakable{
    speak(){
        console.log('TangDuck说话');
    }
    eat(){}  //可以有自己的方法
}

1.3 任意属性

//无法预先知道有哪些新的属性的时候,可以使用 `[propName:string]:any`,propName名字是任意的
interface Person {
  readonly id: number;
  name: string;
  [propName: string]: any;
}

let p1 = {
  id:1,
  name:'zhufeng',
  age:10
}
p1.id = 5 //报错，因为id是只读的

接口的继承

一个接口可以继承自另外一个接口

interface Speakable {
    speak(): void
}
interface SpeakChinese extends Speakable {
    speakChinese(): void
}
class Person implements SpeakChinese {
    speak() {
        console.log('Person')
    }
    speakChinese() {
        console.log('speakChinese')
    }
}

readonly

用 readonly 定义只读属性可以避免由于多人协作或者项目较为复杂等因素造成对象的值被重写

interface Person{
  readonly id:number;
  name:string
}
let tom:Person = {
  id :1,
  name:'zhufeng'
}
tom.id = 1;  // 报错

函数类型接口

对方法传入的参数和返回值进行约束

interface discount{
  (price:number):number
}
let cost:discount = function(price:number):number{
   return price * .8;
}

可索引接口

对数组和对象进行约束
userInterface 表示index的类型是 number，值的类型必须是 string
UserInterface2 表示：index 的类型是 string，值的类型也必须是 string

interface UserInterface {
  [index:number]:string
}
let arr:UserInterface = ['lc1','lc2'];
console.log(arr);

interface UserInterface2 {
  [index:string]:string
}
let obj:UserInterface2 = {name:'lc'};

类接口

对类的约束

interface Speakable {
    name: string;
    speak(words: string): void
}
class Dog implements Speakable {
    name!: string;
    speak(words:string) {
        console.log(words);
    }
}
let dog = new Dog();
dog.speak('汪汪汪');

构造函数的类型

在 TypeScript 中，我们可以用 interface 来描述类
同时也可以使用interface里特殊的new()关键字来描述类的构造函数类型

class Animal{
  constructor(public name:string){
  }
}
interface WithNameClass{
  new(name:string):Animal
}
function createAnimal(clazz:WithNameClass,name:string){
   return new clazz(name);
}
let a = createAnimal(Animal,'lcc');
console.log(a.name);

typescript---接口

推荐阅读更多精彩内容