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();//
         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>