继承

报社有订阅发布的功能。
想让人也有订阅发布的功能，可以写一个更高层级的累，去让人和报社去继承。
这样人和报社都可以有订阅发布

  1. class EventEmitter {
  2.   on(){}
  3.   off(){}
  4.   emit(){}
  5.   constructor(){}
  6. }
  8. class Person extends EventEmitter {
  9.     constructor(){
  10.    super()
  11.   }
  12.   sayHi(){}
  13. }
  15. class baoshe extends EventEmitter {
  16.     constructor(){
  17.    super()
  18.   }
  19.   print(){}
  20. }

重写
  • 子类重写父类的所有属性，以实现多态

  • 多态的意思是不同的子类对同一个消息有不同的反应

    1. class Person extends EventEmitter {
    2.   constructor(public name) {
    3.     super()
    4. }
    5. on(eventName,fn){
    6.     console.log('子类进行监听')
    7.   super.on(eventName,fn)
    8. }
    9. }

    继承有什么问题

    如果这个类需要更多的功能怎么办

  • 让EventEmitter 继承其他类

  • 让Person继承两个类 （多继承，js不支持）
    • 两个方法都不好
    • 所以就可以使用组合

组合

组合并没有固定的写法。

让Person实现发布订阅
如何不使用继承，但是person又能使用on,off,emit三个api

  1. class Person {
  2.     eventEmitter = new EventEmitter()
  3.   name
  4.   sayHi(){}
  5.   on(eventName,fn){
  6.       this.eventEmitter.on(eventName, fn)
  7.   }
  8.   off(eventName,fn){
  9.       this.eventEmitter.off(eventName, fn)
  10.   }
  11.   emit(eventName,data){
  12.       this.eventEmitter.emit(eventName, data)
  13.   }
  14. }

优化代码

  1. class Person {
  2.     sayHi(){}
  3.   name
  4. }
  5. let person 1 = new Person('hasson')
  6. mixin(person1, new EventEmitter())
  8. function mixin(to,from){
  9.     for(let key in from){
  10.       to[key] = form[key]
  11.   }
  12. }

组合例子

  1. dog
  2.     .wangwang()
  3.     .poop() // 拉屎
  5. cat 
  6.     .miaomiao()
  7.     .poop()
  9. 抽象
  10. animal
  11.     .poop()
  12.      dog
  13.        .wangwang()
  14.      cat
  15.     .miaomiao()
  1. cleaningRobot
  2.     .clean()
  3.     .run()
  5. murderRobot
  6.     .kill()
  7.     .run()
  9. 抽象
  10. robot
  11.     .run()
  12.      murderRobot
  13.         .kill()
  14.      cleaningRobot
  15.        .clean()

现在有两个类，动物和机器人
那我现在需要一个狗型杀人机器人，咋整
需要
robot run

  • murderRobot kill

animal poop(不需要)

  • dog wangwang

如果是继承的话，很难只拿wangwang，不继承poop

通过组合：

  • dog = poop() + wangwang()
  • cat = poop() + miaomiao()
  • cleaningRobot = run() + clean()
  • murderRobot = run() + kill()
  • 狗型杀人机器人 = run() + kill() + wangwang()
  1. const createWang = (state)=>({
  2.     wangwang:()=>{
  3.       console.log(`汪汪,我是${state.name}`)
  4.   }
  5. })
  7. const createRun = (state)=>({
  8.     run:()=> state.position +=1
  9. })
  11. const createDog = (name) => {
  12.     const state = {name,position:0}
  13.   return Object.assign(
  14.     {state},
  15.     createWang(state),
  16.     createRun(state)
  17.   )
  18. }
  20. const dog = createDog('小白')

狗型杀人机器人：

  1. const createMurderDogRobot = (name) => {
  2.     const state = {name,position:0}
  3.   return Object.assign(
  4.     {},
  5.     createWang(state),
  6.     createRun(state),
  7.     createKill(),
  8.   )
  9. }
  11. const murderDogRobot = createMurderDogRobot('小黑')

组合能实现扁平化的重新分配
继承是垂直方向的，一旦出现两个垂直方向的交叉，是做不到的