类的继承与接口-一一网

继承

普通继承

class Person {
  name: string;
  constructor(name: string) {
    this.name = name
  }
  run(): string {
    return `${this.name}在跑步`
  }
  getName(): string {
    return this.name
  }
  setName(name: string): void {
    this.name = name
  }
}
//继承上面的方法
class CoolPerson extends Person {
  constructor(name: string) {
    super(name)
  }
  work() {
    console.log(`${this.name}在工作`)
  }
}
const p = new CoolPerson('coolFish')
console.log(p.getName())
复制代码

多态

多态：父类定义一个方法不去实现，让继承他的子类去实现，每一个子类有不同的表现，多态属于继承。

class Animal {
  name: string
  constructor(name: string) {
    this.name = name;
  }
  eat() {
    console.log('吃的方法')
  }
}
class Dog extends Animal {
  constructor(name: string) {
    super(name)
  }
  eat() {
    console.log(`${this.name}吃骨头`)
  }
}
class Cat extends Animal {
  constructor(name: string) {
    super(name)
  }
  eat() {
    console.log(`${this.name}吃鱼`)
  }
}
复制代码

这定义了一个动物，然后猫和狗都继承于动物，但是定义的吃的方法，表现都不一样。

抽象类

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

abstract class Animal {
  public name: string
  constructor(name: string) {
    this.name = name
  }
  abstract eat(): any
}
class Dog extends Animal {
  constructor(name: any) {
    super(name)
  }
  eat() {
    console.log(`${this.name}吃肉`)
  }
}
class Cat extends Animal {
  constructor(name: any) {
    super(name)
  }
  play() {
    console.log(`${this.name}吃鱼`)
  }
}
复制代码

我们看到我们定义了一个动物的抽象类，里面有一个 eat 方法，Dog 继承了，Cat 没有，所以 Cat 就会报错，说不能继承，因为他没实现 eat 方法。

接口

接口的作用：在面向对象的编程中，接口是一种规范的定义，它定义了行为和动作的规范，接口起到一种限制和规范的作用，接口定义了某一批类所需要的遵循的规范。

属性接口

属性接口就是传入对象的约束

interface FullName {
  firstName: string;
  secondName: string;
}
function printName(name: FullName) {
  console.log(name.firstName + name.secondName)
}
printName({ firstName: "123", threeName: "1231" }) //错误，不符合接口定义
printName({ firstName: "123", secondName: "1231" })
let aug = {
let arg = {
  age: 20,
  firstName: '123',
  secondName: '123'
}
printName(arg) //不会报错，当以对象的形式传入，只要有符合即可
复制代码

上例，我定义了一个属性接口，有两个属性，且类型为字符串，参数类型为这个接口，所以这个参数也是对象，内部的属性和类型都得一一对应，如果是以对象的形式传入，那么对象中有符合的属性即可。

函数类型接口

interface encrypt {
  (key: string, value: string): string;
}
var md5: encrypt = function (key: string, value: string): string {
  return key + value
}
var sha1: encrypt = function (key: string, value: string): string {
  return key + '---' + value
}
console.log(md5('name', 'coolFish'))
console.log(sha1('name', 'liSi'))
复制代码

定义了函数的入参和出参。

类类型接口（用的多）

类类型接口：对类的约束，和抽象类有点像。
抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能还有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

interface Animal {
  name: string;
  eat(str: string): void;
}
class Dog implements Animal {
  name: string
  constructor(name: string) {
    this.name = name
  }
  eat() {
    console.log(this.name + '吃肉')
  }
  play() {
    console.log('123')
  }
}
复制代码

类类型接口，定义了类的属性和方法。

接口扩展

接口扩展：接口可以继承接口

interface Animal {
  eat(): string
}
interface Person extends Animal {
  work(): void
}
class Web implements Person {
  public name: string
  constructor(name: string) {
    this.name = name
  }
  eat() {
    return '123'
  }
  work() {
    console.log(321)
  }
}
复制代码

继承+实现接口

interface Animal {
  eat(): string
}
interface Person extends Animal {
  work(): void
}
class CoolFish {
  public name: string
  constructor(name: string) {
    this.name = name
  }
  play() {
    console.log('打游戏')
  }
}
class Web extends CoolFish implements Person {
  public name: string
  constructor(name: string) {
    super(name)
    this.name = name
  }
  eat() {
    return '123'
  }
  work() {
    console.log(321)
  }
}
let w = new Web('coolFish')
w.play()
复制代码