javascript之继承

主要是参考了《JavaScript高级程序设计（第三版）》这本书，根据自己的理解，做了下面的记录

继承是面向对象（OO）语言里面的概念，有俩种继承方式：接口继承和实现继承。接口继承只继承方法签名，而实现继承则继承实际的方法。由于函数没有签名，在javascript里面无法实现接口继承，只支持实现继承。

原型链继承

   构造函数、原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。

  

   所有函数的默认原型都是Object的实例

   那如果让原型对象等于另一个类型的实例会怎么样呢？显然，此时的原型对象将包含一个指向另一个原型的指针，相应地，另一个原型也包含着指向另一个构造函数的指针。

   具体代码： 

   function SuperType() {
      this.proterty = true
    }
    SuperType.prototype.getSuperValue = function () {
      return this.proterty
    }
    function SubType() {
      this.subproperty = false
    }
    //继承了SuperType
    SubType.prototype = new SuperType()
    SuperType.prototype.getSubValue = function () {
      return this.subproperty
    }
    var instance = new SubType()
    instance.getSuperValue()  //true

判断原型和实例的关系

使用instance或者isPrototypeOf

    alert(instance instanceof SubType)  //  true
    alert(SubType.prototype.isPrototypeOf(instance))  // true

缺点：

 （一）、只要某个实例、构造函数、原型对象修改了属性或方法，会对原型链上的其他对象实例造成影响

 （二）、在创建了类型的实例时，没有办法在不影响谁有对象实例的情况下，给超类型的构造函数传递参数

借用构造函数

    

    function SuberType() {
      this.colors = ["red","blur"]
    }
    function SubType() {
      //继承了SuberType 
      //使用了call改变了this的作用域，用apply也可以
      SuberType.call(this)
    }
    var instance = new  SubType()
    instance.colors.push("black")
    alert(instance.colors) //red,blur,black

var instalce2 = new SuberType() 14 alert(instalce2.colors) // red,blur

优点：可以在子类型构造函数中向超类型构造函数传递参数

     function SuberType(name) {
        this.name = name
      }
      function SubType() {
        //继承了SuberType，还传递了参数
        SuberType.call(this,"zhao")
        this.age = "27"
      }
      var instance = new SubType()
      alert(instance.name) //zhao
      alert(instance.age) //27

缺点：

方法都在构造函数中定义，函数无法复用。而且在超类型的原型中定义的方法，子类型是不可见的

组合继承

     原型链和构造函数的技术组合到一起。思路是使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承

     

   function SuberType(name) {
      this.name = name
      this.colors = ["red","blue"]
    }
    SuberType.prototype.sayName = function () {
      alert(this.name)
    }
    function SubType(name,age) {
      //继承属性
      SuberType.call(this, name)  // 第一次调用SuberType()
      this.age = age
    }
    //继承方法
    SubType.prototype = new SuberType()  //第二次调用SuberType()
    SubType.prototype.sayAge = function () {
      alert(this.age)
    }
    var instance1 = new SubType("zhao", 27)
    instance1.colors.push("black")
    alert(instance1.colors) // red,blue,black
    instance1.sayName() // zhao
    instance1.sayAge()  //27

    var instance2 = new SubType("w", 28)
    alert(instance2.colors) // red,blue
    instance2.sayName() // w
    instance2.sayAge() // 28

优点：实例有各自的属性，和相同的方法

缺点：会俩次调用超类型的构造函数

原型式继承

    借助原型可以基于已有的对象创建新对象，不必因此自定义类型

    

   function object(o) {
      function F() {}
        F.prototype = o
        return new F()6     }

上面这个函数的本质是：object()对传入的对象执行了一次浅复制

 var person = {
      name: 'zhao',
      friends: ['zhao1','zhao2','zhao3']
    }
    var anotherPerson = object(person)
    anotherPerson.name = 'ss'
    anotherPerson.friends.push('Bob')

    var yetAnotherPerson = object(person)
    yetAnotherPerson.name = 'rr'
    yetAnotherPerson.friends.push('Bar')
    alert(person.friends) //zhao1,zhao2,zhao3,Bob,Bar

ECMAScript5通过新增Object.create()方法规范了原型式继承，这个方法接收俩个参数，一个用作新对象原型的对象和（可选的）一个为新对象定义额外属性的对象

在传入一个参数的情况下，Object.create()和object()一样

    var person = {
      name: 'zhao',
      friends: ['zhao1','zhao2','zhao3']
    }
    var anotherPerson = Object.create(person)
    anotherPerson.name = 'ss'
    anotherPerson.friends.push('Bob')

    var yetAnotherPerson = Object.create(person)
    yetAnotherPerson.name = 'rr'
    yetAnotherPerson.friends.push('Bar')
    alert(person.friends) //zhao1,zhao2,zhao3,Bob,Bar

Object.create()的第二个参数会覆盖原型对象上的同名属性

    var person = {
      name: 'zhao',
      friends: ['zhao1','zhao2','zhao3']
    }
    var anotherPerson = Object.create(person)
    anotherPerson.name = 'ss'
    anotherPerson.friends.push('Bob')

    var yetAnotherPerson = Object.create(person)
    yetAnotherPerson.name = 'rr'
    yetAnotherPerson.friends.push('Bar')
    alert(person.friends) //zhao1,zhao2,zhao3,Bob,Bar

寄生式继承

   思路：创建一个仅用与封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真地是它做了所有工作一样返回对象

   

<script>
     function object(o) {
       function F() {}
       F.prototype = o
       return new F()
     }

     function createAnother(original) {
       var clone = object(original)  // 通过调用函数创建一个新对象
       clone.sayHi = function () {  // 以某种方式来增强这个对象
         alert("hi")
       }
       return clone  //返回这个对象
     }
     var person = {
       name: "zhaobao",
       friends: ["zhaobao1","zhaobao2","zhaobao3"]
     }
     var anotherPerson = createAnother(person)
     anotherPerson.sayHi() // hi
   </script>

寄生组合式继承

    这个主要是为了解决组合继承的缺点

   思路：通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。

              不必为了指定子类型的原型而调用超类型的构造函数，我们需要的只是超类型原型的一个副本。

               本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。

       基本模式

           

  function inheritPrototype(subType, superType) {
       var prototype = object(superType) //创建对象
       prototype.constructor = subType  // 增强对象
       subType.prototype = prototype  //指定对象
     }

例子

  

function inheritPrototype(subType, superType) {
       var prototype = object(superType) //创建对象
       prototype.constructor = subType  // 增强对象
       subType.prototype = prototype  //指定对象
     }
     function SuperType(name) {
       this.name = name
       this.colors = ["red","blue"]
     }
     SuperType.prototype.sayName = function () {
       alert(this.name)
     }
     function SubType(name,age) {
       SuperType.call(this,name)
       this.age = age
     }
     inheritPrototype(SubType,SuperType)
     SuperType.prototype.sayAge = function () {
       alert(this.age)
     }

 这个例子的高效率提现在它只调用了一次SuperType构造函数，并且因此避免了在SubType.prototype上面创建不必要的、多余的属性。与此同时，原型链还能保持不变，因此，还能正常使用instanceof和isPrototypeOf()

这是最理想的继承方式