javascript——面向对象程序设计（4）

    <script type="text/javascript">
        //1、继承
        //2、原型链
        //3、借用构造函数
        //4、组合继承
        //5、原型式继承
        //6、寄生式继承
        //7、寄生组合式继承

        //1、继承是OO中最让人津津乐道的概念。许多OO语言都支持两种继承方式：接口继承和实现继承。
        //接口继承只支持方法签名，而实现继承则继承实际的方法。
        //由于函数没有签名，所以在ECMAScript中无法实现接口继承，只支持实现继承，而且其实现继承主要由原型链来实现。

        //2、原型链。
        //简单回顾一下，构造函数、原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针
        //而实例都包含一个指向原型对象的内部指针。
        //而如果我们让原型对象指向另一个类型的实例，结果会怎样呢？显然，此时的原型对象将包含一个指向另一个原型的指针，
        //相应的,另一个原型中也包含着一个指向另一个构造函数的指针。假如另一个原型又是另一个类型的实例，那么上述关系依然成立，
        //就构成了实例与原型的链条。这就是所谓原型链的基本概念。eg:

        //动物类
        function Animal() {
            this.shout = "不知道";
        }
        Animal.prototype.getAnimalValue = function () {
            return this.shout;
        }

        //狗狗类
        function Dog() {
            this.dogShout = "汪汪汪~";
        }

        ///狗狗类继承动物类
        Dog.prototype = new Animal();

        Dog.prototype.getDogValue = function () {
            return this.dogShout;
        }

        var instance = new Dog();
        //狗狗类调用动物类叫的方法
        alert(instance.getAnimalValue())
        //instance.getAnimalValue()会经历3个步骤，1、搜索实例 2、搜索Dog.prototype 3、搜索Animal.prototype
        //a、别忘记默认的原型。大家要记住，所有的函数的默认原型都是Object的实例，因此默认原型都会有一个内部指针，
        //指向Object.prototype。这也正是自定义类都会继承toString()和valueOf()的方法的根本原因


        //b、确定原型和实例的关系
        alert(instance instanceof Object);//true
        alert(instance instanceof Animal);//true
        alert(instance instanceof Dog);//true


        alert(Object.prototype.isPrototypeOf(instance));//true
        alert(Animal.prototype.isPrototypeOf(instance));//true
        alert(Dog.prototype.isPrototypeOf(instance));//true

        //c、原型链的问题
        //想必大家还记得，前面介绍过含引用类型值的原型会被所有的实例共享，
        //这也是为什么要在构造函数中，而不是在原型对象中定义属性的原因。
        //所以，实践中很少有人单独使用原型链。


        //3、借用构造函数（又叫：伪造对象或经典继承）
        //这种继承的方式很简单，就是在子类构造函数内部调用超类构造函数使用call或apply
        function Animal() {
            this.colors = ['red', 'blue', 'green'];
        }

        function Dog() {
            //继承了Animal类
            Animal.call(this);
        }

        var dog = new Dog();
        dog.colors.push("black");
        alert(dog.colors);//'red','blue','green','black'

        var dog2 = new Dog();
        alert(dog2.colors);//'red','blue','green'

        //相对于原型链而言，借用构造函数有很大的优势，即可以在子类构造函数中向超类传递参数
        function Animal2(name) {
            this.name = name;
        }

        function Dog2() {
            //继承了Animal类
            Animal2.call(this, "大黄");
            this.age = 2;
        }

        var dog = new Dog2();
        alert("年龄：" + dog.age + "，名称：" + dog.name);

        //因为方法都在构造函数中定义,因此函数复用就无从谈起了。而且在超类原型中定义的方法，对于子类型而言也是不可见的
        //结果所有类型都只能使用构造函数模式。
        //考虑到这些问题，借用构造函数的技术也很少单独使用。

        //4、组合继承
        function Animal3(name) {
            this.name = name;
            this.colors = ['red', 'blue', 'green'];
        }

        Animal3.prototype.sayName = function () {
            alert(this.name)
        }

        function Dog3(name, age) {
            //继承属性
            Animal3.call(this, name);
            this.age = age;
        }
        //继承方法
        Dog3.prototype = new Animal3();
        Dog3.prototype.constructor = Dog3;
        Dog3.prototype.sayAge = function () {
            alert(this.age)
        }

        var d3 = new Dog3("小黄", 1);
        d3.colors.push("black");
        alert(d3.colors);//red,blue,green,black
        d3.sayAge();//1
        d3.sayName();//小黄

        //组合继承避免了原型链和借用构造函数的缺陷，融合了他们的优点，成为javascript中最常用继承方式
        //而且instanceof 和 isPrototypeOf也能够用于识别基于组合继承创建的对象。

        //5、原型式继承
        //在没有必要兴师动众的创建构造函数，而只想让一个对象与另一个对象保持类似的情况下，原型式继承是完全可以胜任的
        //不过别忘了:包含引用类型的值的属性始终都会共享相应的值，就像使用原型模式一样。

        var Person={
            name:'xulei',
            friends:['张三','李四','王五']
        }

        var p1=Object.create(Person);
        p1.name="徐磊1";
        p1.friends.push("killey");
        var p2=Object.create(Person);
        p2.name="徐磊2";
        p2.friends.push("jack");


        alert("p1.name:"+p1.name);//徐磊1
        alert("p1.friends:"+p1.friends);//张三','李四','王五','killey','jack'
        alert("p2.name:"+p2.name);//徐磊2
        alert("p2.friends:"+p2.friends);//张三','李四','王五','killey','jack'


        //6、寄生式继承
        //寄生式继承是与原型式继承紧密相关的一种思路。寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数
        //该函数在内部以某种方式来增强对象，最后再像真的是它做了所有工作一样返回对象。eg：
        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 Person2={
            name:'xulei',
            friends:['张三','李四','王五']
        }

        var p3=createAnother(Person2);
        p3.sayHi();


        //7、寄生组合式继承
        //前面说过，组合继承是最常用继承模式，不过它也有自己的不足。
        //组合继承最大的问题就是无论在什么情况下，都会调用两次超类型的构造函数：一次是在创建子类型原型的时候，另一次是在子类型构造函数内部
        //eg:
        function SuperType(name){
            this.name=name;
            this.colors=['red','blue','green'];
        }

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

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

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

        //好在已经有更好的解决方案————寄生组合式继承
        //所谓寄生组合式继承就是借用构造函数来继承属性，通过原型链的混成形式来继承方法。
        //其背后的基本思路是：不必为了指定子类型的原型而调用超类型的构造函数，我们所需要的无非是超类型原型的一个副本而已
        //本质上，就是使用寄生继承来继承超类型的原型，然后再将结果指定给子类型的原型。eg:
        function object(o) {
            function F() { }
            F.prototype=o;
            return new F();
        }
        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(){
            alert(this.name);
        }

        function SubType(name,age) {
            SuperType.call(this,name);
            this.age=age;
        }
        inheritPrototype(SubType,SuperType);
        SubType.prototype.sayAge=function(){
            alert(this.age);
        }

        var p4=new SubType("张三",29);
        p4.sayName();
        //这个例子的高效率体现在它只调用了一次SuperType构造函数，并且因此避免了在SubType.prototype上创建不必要的、多余的属性
        //与此同时，原型链还能保持不变；因此还能正常的使用instanceOf 和isPrototypeOf
        //普遍认为寄生组合继承是引用类型最理想的继承方式。





    </script>