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()  alert(instalce2.colors) // red,blur

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

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

缺点：

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

组合继承

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

    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", )
     instance1.colors.push("black")
     alert(instance1.colors) // red,blue,black
     instance1.sayName() // zhao
     instance1.sayAge()  //

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

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

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

原型式继承

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

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

上面这个函数的本质是：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()

这是最理想的继承方式