抽象类

所谓抽象类，是指用abstract修饰的类。抽象类是不完整的，它只能作为基类，不能够被实例化。简而言之，抽象类本身不做任何事情，他是去要求别人来实现自己的规范。它定义了一组抽象方法，至于抽象方法的实现则交由它的子类来完成。

• 抽象类特点

1.抽象类只是一个引用而已，不能被实例化，实例化的工作要交给它的子类；
2.抽象方法必须由子类来进行重写；
3.在一个类中，只要有一个方法被定义为抽象方法，那么这个类就必须被定义为抽象类，若子类没有重写父类全部的抽象方法，则必须为抽象类。 
4.抽象类中可以包含具体方法，也可以不包含；
5.子类中的抽象方法不能与父类的抽象方法同名；
6.不能用abstract修饰变量、代码块、构造器； 
7.不能用abstract修饰私有方法、静态方法、final的方法、final的类

• 语法

abstract class 类名 {
  
  属性名:类型;
  
  constructor(参数：类型) {
    this.属性名 = 参数
  }
  
  abstract 方法名():类型；
}

class 子类 extends 父类{
  
  子类特有属性:类型;
  
  //子类构造函数
  constructor(参数1:类型,参数2:类型,参数3:类型){
    //super可以用来调用父类的属性，方法和构造函数
    super(参数1,参数2); //调用父类构造函数
    this.属性名 = 参数3
  }
  
  //一定要实现父类有的抽象方法，否则会报错
  父类方法名(){
    ……
    }
}

• 实例展示

abstract class Person {
  
  name:string;
  age:number;
  
  constructor(name:string,age:number) {
    this.name = name
    this.age = age
  }
  
 abstract sayHi():void;
}

class Chinese extends Person{
  
  country:string;
  
  constructor(name:string,age:number,country:string){
    super(name,age);
    this.country = country
  }
  
  //实现了父类的抽象方法
  sayHi(){
    console.log(`${this.name}说了声你好`)
  }  
}

接口

在在面向对象语言中，接口是一个重要的概念。它是对行为的抽象，而具体如何星斗则交由类来实现。而在TS中接口是一个很灵活的概念，他可以定义对象类型，函数类型，类类型，还可以定义属性只读，属性可选等操作。

• 属性接口

通过interface关键字就定义一个接口，接口里面是的属性类型的约束。在不添加特殊标识的时候，当我们将接口作为一个变量的类型的时候，该变量必须将接口里面的属性完整定义否则会报错。

• 语法

interface 接口名{
  属性名:类型
  
  //属性前添加readonly表示该属性是只读属性，无法更改
  readonly 属性名:类型
  
  //属性后面添加?表示该属性为可选属性，可添加也可以不添加
  属性名?:类型
}

• 实例

interface Student{
  
  name:string
  age:number
	
  //属性前添加readonly表示该属性是只读属性，无法更改
  readonly score:number
  
  //属性后面添加?表示该属性为可选属性，可添加也可以不添加
  sex?:string
}

let stu: Student = {
  name:"吴名小卒",
  age:18,
  score:99
}

stu.age = 20
console.log(stu)
  
stu.score = 100  //报错，score是只读属性，不能更改数值

• 函数接口

函数接口主要分为函数属性接口和函数类型接口两种。两种接口针对函数的不同方面进行了约束。

1、函数属性接口：用于约束函数的参数和返回值的类型
2、函数类型接口：用于约束函数的类型

• 语法

// 函数属性接口语法
interface 接口名{
  属性名:类型
  属性名:类型
}

function 函数名(参数名:接口名):返回值类型{
  ……
}

// 函数类型接口语法
interface 接口名{
  (属性名:类型，属性名:类型)：返回值类型
}

const 函数名:接口名 = (属性名，属性名) =>{
  ……
}

• 实例

//函数属性接口
interface Params{
  a:number
  b:number
}

function sum(params:Params):number{
  return params.a + params.b
}

//函数类型接口
interface Sum{
  (params:Params):number
}

const sub:Sum = (params) =>{
  return params.a - params.b
}

console.log(sum({a:2,b:1}))   //3
console.log(sub({a:2,b:1}))   //1

• 类类型接口

类类型接口主用于约束类中的内容，类类型接口有点类似于抽象类，在接口中定义类的公共属性和方法，但都没有实现，具体实现交由类来完成。类通过implement关键字来实现接口，并在类中实现接口中所有非可选的方法。

• 语法：

interface 接口名{
  属性名:类型;
  属性名:类型;
  
  方法名(参数:类型):返回值类型;
}

class 类名 implements 接口名{
  
  接口属性:类型;
  接口属性:类型;
  属性：类型;
  
  接口方法(参数:类型){
    ……
  }
}

• 实例

interface People{
  name:string;
  age:number;
  
  sayHi():void;
}

class Man implements People{
  name:string;
  age:number;
  sex = "男";
  
  constructor(name:string,age:number){
    this.name = name;
    this.age = age;
  }
  sayHi(){
    console.log("你好！！");
  }
}

抽象类和接口的对比

1、抽象类当作父类，被继承。而且抽象类的子类的构造函数必须调用super()。而接口可以作为子类继承其他的类；
2、抽象类和接口都无法被实例化。
3、抽象类中除了抽象方法之外，其余函数能包含具体实现，而接口中不包含具体实现。
4、抽象类所有的抽象方法在子类中都必须被实现，接口中的非可选方法在接口被调时也都要实现。
5、抽象类的方法可以被当成类的实例方法，被访问修饰符修饰。但接口不行。

总结

本篇文章主要以TS语法为基础，展开讲述了在面向对象中的两大知识点：抽象类与接口。同时，对抽象类和方法进行了对比，找出了两者之间的异同之处。