javaScript面向对象—继承

继承的概念

继承:子类可以访问父类的所有属性和方法，并且可以对这些属性和方法进行扩展

继承的几种方式

• 原型链继承

  利用原型让一个对象继承另一个对象的属性和方法，，即把一个对象的原型作为另一个对象的实例，这样就可以继承另一个对象的属性和方法

  优点：

  1. 简单易于实现，父类的新增的实例与属性子类都能访问

  缺点：

  1. 子类更改从父类继承过来的引用类型的属性，由于原型属性中的引用类型属性会被所有实例共享，因此会影响其他实例
  2. 创建子类实例时，没有办法在不影响其他实例的情况下向超类型的构造函数中传参、
  3. 可以在子类中增加实例属性，如果要新增加原型属性和方法需要在new 父类构造函数的后面
  4. 无法实现多继承、
  5. 创建子类实例时，不能向父类构造函数中传参数

  function People (name){
      this.name = name
      this.say = function(){
          console.log('hello')
      }
  }
  
  // 01.原型链继承
  
  function Child1 (age) {
      this.age = age
  }
  Child1.prototype = new People('xiaoming')
  let xiaoming = new Child1(18)
  console.log(xiaoming.name,xiaoming.age) // xiaoming 18
  

• 借用构造函数

  在函数内部通过call或apply去继承超类型属性或方法

  优点：

  1. 解决了子类构造函数向父类构造函数中传递参数
  2. 可以实现多继承（call或者apply多个父类）

  缺点：

  1. 方法都在构造函数中定义，无法复用
  2. 不能继承原型属性/方法，只能继承父类的实例属性和方法

  function People (name){
      this.name = name
      this.say = function(){
          console.log('hello')
      }
  }
  
  function Child2 (name,age) {
      People.call(this,name)
      this.age = age
  }
  
  let xiaoming = new Child2('xiaoming',18)
  console.log(xiaoming.name,xiaoming.age) // xiaoming 18
  

• 组合继承

  使用原型链实现原型属性和方法的继承，使用借用构造函数来实现对实例属性的继承

  优点：

  1. 函数可以复用
  2. 不存在引用属性问题
  3. 可以继承属性和方法，并且可以继承原型的属性和方法

  缺点: 需要调用两次父类

  function People (name){
      this.name = name
      this.say = function(){
          console.log('hello')
      }
  }
  
  function Child3(name,age){
      this.age = age 
      People.call(this,name)// 第一次调用
  }
  Child3.prototype = new People('xiaoming')//第二次调用
  People.prototype.constructor = People
  let xiaoming = new Child3('xiaoming',18)
  console.log(xiaoming.name,xiaoming.age) // xiaoming 18
  

• 原型式继承

  把一个对象作为另一个对象的基础，通过一个中介构造函数去创建一个实例。

  // 方式1
  function object(o) {
    var F = function(){}
    F.prototype = o
    return new F()
  }
  var person2 = object(obj)
  // 方式2
  var person1 = Object.create(obj, {
  name: {
    value: 'person1'
  }})
  

• 寄生式继承

  创建一个用来封装继承过程的函数，在该函数的内部通过某种方式来增强对象，然后返回这个对象。

  • 可以将最开始的对象扩展后,返回被继承

  • 通原型链继承一样,此时无法获取到构造函数属性

  • 寄生继承直接指向父类的prototype,所以不会重复调用父类的情况

  let obj = {
      name: '小明',
      age: 18,
      like: ['吃饭', '睡觉']
  }
  
  function createFn(ob) {
      let o = Object.create(ob)
      o.sayHi = function () {
          console.log('hi')
      }
      return o
  }
  
  let child4 = createFn(obj)
  console.log(child4.name,child4.age)// 小明 18
  

• 寄生组合继承

  通过借用构造函数方式继承属性，通过原型链混成方式继承方法

  通过寄生的方式来修复组合式继承的不足，完美的实现继承

  People.prototype.eat = function () {
      console.log('吃饭')
  }
  //子类
  function  Man(name,age) {
      People.call(this,name)
      this.age = age
  }
  
  //继承父类的方法
  function  createFn(father,child) {
      let o = Object.create(father.prototype)
      console.log(o)
      o.constructor = child
      child.prototype = o
  }
  createFn(People, Man)
  let person1 = new Man('xiaoming',18)
  console.log(person1.name,person1.age)// xiaoming 18
  

• ES6继承

  class People {
      constructor(name ,age){
          this.name = name
          this.age = age
      }
      like () {
          console.log('吃饭','睡觉')
      }
  }
  
  class Man extends People {
      constructor(name,age){
          //继承父类属性
          super(name,age)
      }
      like () {
          super.like()
      }
  }
  
  let people = new Man('xiaoming',18)
  console.log(people.name,people.age)//xiaoming 18
  people.like()