面向对象的程序设计-继承

原型链

---

就是让一个原型等于另一个类的实例，以此类推

   function SuperType(){
        this.property = true;
   }

   SuperType.prototype.getSuperValue = function(){
        return this.property;
   };

   function SuberType(){
       this.property = false;
   }

   SuberType.prototype = new SuperType();

   SuberType.prototype.getSuberValue = function(){
       return this.property;
   }

   var instance = new SuberType();
   console.log(instance.getSuperValue()); //true

 要注意instance.constructor现在指向的是SuperType，这是因为原来SubType.prototype中的constructor被重写了

1、别忘记默认的原型

所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部函数指针，指向Object.prototype。

SubType继承了SuperType，而SuperType继承了Object。当调用instance.toString()时，实际上调用的是保存在Object.prototype中的那个方法

2、确定原型和实例的关系

第一种方式使用instanceof操作符，只要用这个操作符测试实例与原型中出现过得构造函数，就会返回true

     console.log(instance instanceof Object); //true
     console.log(instance instanceof SuperType); //true

第二种方式是使用isPrototypeOf()方法

     console.log(Object.prototype.isPrototypeOf(instance)); //true
     console.log(SuperType.prototype.isPrototypeOf(instance)); //true

3、谨慎的定义方法

子类型有时候需要覆盖超类型中的某个方法，或者需要添加超类型中不存在的某个方法。但不管怎样，给原型添加方法的代码一定要放在替换原型的语句之后

    function SuperType(){
         this.property = true;
    }

    SuperType.prototype.getSuperValue = function(){
         return this.property;
    };

    function SuberType(){
        this.property = false;
    }

    SuberType.prototype = new SuperType();

    SuberType.prototype.getSuberValue = function(){
        return this.property;
    }
    SuberType.prototype.getSuperValue = function(){
        return false;
    }

    var instance = new SuberType();
    console.log(instance.getSuperValue()); //false

还有一点需要注意，即在通过原型链实现继承时，不能使用对象字面量创建原型方法，因为这样就会重写原型链

    function SuperType(){
         this.property = true;
    }

    SuperType.prototype.getSuperValue = function(){
         return this.property;
    };

    function SuberType(){
        this.property = false;
    }

    SuberType.prototype = new SuperType();

    SuberType.prototype = {
        getSuberValue : function(){
            return this.subproperty;
        },
        someOtherMethod : function(){
            return false;
        }
    };

    var instance = new SuberType();
    console.log(instance.getSuperValue()); //error

4、原型链的问题

虽然原型链很强大，可以用它来实现继承，但它也存在一些问题。其中，最主要的问题来自包含引用类型值的原型，前面介绍过包含引用类型值的原型属性会被所有的实例共享

    function SuperType(){
        this.colors = ["red","blue","green"];
    }

    function SuberType(){

    }

    SuberType.prototype = new SuperType();

    var instance1 = new SuberType();
    instance1.colors.push("black");
    console.log(instance1.colors); //["red", "blue", "green", "black"]

    var instance2 = new SuberType();
    console.log(instance2.colors); //["red", "blue", "green", "black"]

原型链的第二个问题是：在创建子类型的实例时，不能向超类型的构造函数中传递参数

借用构造函数

---

这种技术的思想相当简单，就是在子类型构造函数内部调用超类型构造函数。别忘了，函数只不过是在特定环境中执行代码的对象，因此通过使用apply()和call()方法也可以在（将来）新创建的对象上执行构造函数

   function SuperType(){
        this.colors = ["red","blue","green"];
   }
   function SuberType(){
           SuperType.call(this);
   }
   var instance1 = new SuberType();
   instance1.colors.push("black");
   console.log(instance1.colors); //["red", "blue", "green", "black"]

   var instance2 = new SuberType();
   console.log(instance2.colors); //["red", "blue", "green"]

我们实际上在新创建的SubType实例的环境下调用了SuperType构造函数

1、传递参数

   function SuperType(name){
       this.name = name;
   }

   function SuberType(){
       //继承了SuperType，同时还传递了参数
       SuperType.call(this,"Nicholas");
       this.age = 29;
   }

   var instance = new SuberType();
   console.log(instance.name); //Nicholas
   console.log(instance.age); //29

2、借用构造函数的问题

方法都在构造函数中定义，因此函数复用就无从谈起了。而且，在超类型的原型中定义的方法，对子类型而言也是不可见的，结果所有类型都只能使用构造函数模式

组合继承

---

组合有时候也叫伪经典继承，值得是将原型链和借用构造函数的技术组合到一块，从而发挥二者之长的一种继承模式，其思路是使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承

     function SuperType(name){
         this.name = name;
         this.colors = ["red","blue","green"];
     }

     SuperType.prototype.sayName = function(){
         console.log(this.name);
     };

     function SubperType(name,age){
         SuperType.call(this,name);
         this.age =age;
     }

     SubperType.prototype = new SuperType();
     SubperType.prototype.constructor = SubperType;
     SubperType.prototype.sayAge = function(){
         console.log(this.age);
     };

     var instance1 = new SubperType("Nicholas",29);
     instance1.colors.push("black");
     console.log(instance1.colors); //["red", "blue", "green", "black"]
     instance1.sayName(); //Nicholas
     instance1.sayAge(); //29

     var instance2 = new SubperType("Greg",27);
     console.log(instance2.colors); //["red", "blue", "green"]
     instance2.sayName(); //Greg
     instance2.sayAge(); //27

组合继承成为JavaScript中最常用的继承模式

原型式继承

---

道格拉斯.克罗克福德介绍了这一种继承的方法，思路是借助原型可以基于已有的对象创建新的对象，同时还不必因此创建自定义类型为了达到这个目的，他给出了以下函数

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

    var person = {
        name: "Nicholas",
        friends: ["Shelby","Court","Van"]
    };

    var anotherPerson = object(person);
    anotherPerson.name = "Greg";
    anotherPerson.friends.push("Rob");

    var yetAnotherPerson = object(person);
    yetAnotherPerson.name = "Linda";
    yetAnotherPerson.friends.push("Barbie");

    console.log(person.friends); //["Shelby", "Court", "Van", "Rob", "Barbie"]

这以为着person.friends不仅属于person所有，而且也会被anotherPerson以及yetAnotherPerson共享ECMAScript5通过新增Object.create()方法规范化了原型式继承，这个方法接受两个参数。在传入一个参数的情况下与object()方法的行为相同

    var person = {
        name: "Nicholas",
        friends: ["Shelby","Court","Van"]
    };

    var anotherPerson = Object.create(person);
    anotherPerson.name = "Greg";
    anotherPerson.friends.push("Rob");

    var yetAnotherPerson = Object.create(person);
    yetAnotherPerson.name = "Linda";
    yetAnotherPerson.friends.push("Barbie");

    console.log(person.friends); //["Shelby", "Court", "Van", "Rob", "Barbie"]

Object.create()方法的第二个参数与Object.defineProperties()方法的第二个参数格式相同：每个属性都是通过自己的描述符定义的。以这种方式指定的任何属性都会覆盖原型对象上的同名属性

    var person = {
        name: "Nicholas",
        friends: ["Shelby","Court","Van"]
    };

    var anotherPerson = Object.create(person,{
        name: {
            value: "Greg"
        }
    });

    console.log(anotherPerson.name); //Greg

寄生式继承

---

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

    function createAnother(original){
        var clone = object(orininal);
        clone.sayHi = function(){
            console.log("hi");
        }
        return clone;
    }    

可以像下面这样使用createAnother()函数

    function createAnother(original){
        var clone = object(orininal);
        clone.sayHi = function(){
            console.log("hi");
        }
        return clone;
    }    

    可以像下面这样使用createAnother()函数

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

    function createAnother(original){
        var clone = object(original);
        clone.sayHi = function(){
            console.log("hi");
        }
        return clone;
    }    

    var person = {
        name: "Nicholas",
        friends: ["Shelby","Court","Van"]
    };

    var anotherPerson = createAnother(person);
    anotherPerson.sayHi();//hi

寄生组合式继承

---

    组合继承的最大问题就是无论在什么情况下，都会调用两次超类型函数；

    function SuperType(name){
        this.name = name;
        this.colors = ["red","blue","green"];
    }

    SuperType.prototype.sayName = function(){
        console.log(this.name);
    };

    function SubperType(name,age){
        SuperType.call(this,name);                            //第二次调用SuperType()
        this.age =age;
    }

    SubperType.prototype = new SuperType();                    //第一次调用SuperType()
    SubperType.prototype.constructor = SubperType;
    SubperType.prototype.sayAge = function(){
        console.log(this.age);
    };

有两组name和colors属性：一组在石丽尚，一组在SubType原型中。这就是调用两次SuperType构造函数的结果解决这个问题的方法就是寄生组合式继承，即通过借用构造函数来继承属性，通过原型链的混成形式来继承方法寄生组合式继承的基本模式如下所示

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

 可以改写上面的例子

    function SuperType(name){
        this.name = name;
        this.colors = ["red","blue","green"];
    }

    SuperType.prototype.sayName = function(){
        console.log(this.name);
    };

    function SubperType(name,age){
        SuperType.call(this,name);                        
        this.age =age;
    }

   inheritPrototype(SubperType,SuperType)                
    SubperType.prototype.constructor = SubperType;
    SubperType.prototype.sayAge = function(){
        console.log(this.age);
    };

 开发人员普遍认为寄生组合式继承时引用类型最理想的继承范式