原型以及继承开发模式[JavaScript_010]

原型

---

• 定义：是function 对象的一个属性，构造函数制造出的所有对象的共同祖先，通过该狗奥函数产生的对象，可以继承原型的属性和方法。
• 特点：原型也是对象(prototype ={})

Car.prototype.speed =50;
    function Car()
    {
    };
var car1 = new Car();
var car2 = new Car();
//输出的car1.speed和car2.speed的值为50，原因是从公共对象(原型)继承

• 作用：可以提取共同的属性进行合并处理。
• 操作(从子类)：若对原型进行修改，不能像对象那样直接赋值修改
• 查询：查询实例化的构造函数使用constructor属性

function Car()
{
}
Car.prototype.constructor = Person();//对原型的构造函数查看内容进行篡改
function Person()
{
}
var myCar = new Car();
console.log(myCar.constructor )//会输出篡改后的Person()

• 查询：proto指向原型，可以被修改，一般存储原型。

    function Animal(){
          var this = {
                __proto__ : Animal.prototype
          }; 
    }

• 修改：proto可以被修改，例如：

    Animal.prototype.name = "Alice";
    function Animal(){          
    }
    var cat(){
          name:"Sunny"
    }
    var cat = new Animal();
    cat.__proto__ = cat;//__proto__用于存储原型，此处被修改
    console.log(cat.name);//输出为Sunny,并非Alice

    Animal.prototype.name = "A";
    function Animal(){          
    }
    var cat = new Animal();
    //Animal.prototype.name = "C" (改属性)
    Animal.prototype{//(改空间)
          name:"B"
    }
    //输出的cat.prototype.name 为A
    //1.若注释的取消则为C
    //2.若B在对象之前修改才输出B

输出A的原因是，Animal.prototype换了存储内容，但是__proto__还是原来的继承，为A

• Object.prototype是所有对象的最终原型，处于原型链的顶端

Object.create()

• 作用：构建对象

    Animal.prototype.name = "A";
    function Animal(){          
    }
    var animal  = Object.Create(Animal);   

• 不是所有的类的父类都是Object.prototype,
• 例如：Object.Create(null);

重写方法(toString)

    Animal.prototype.toString=function (){       
        console.log('A');   
    }
    var animal  = Object.Create(Animal);     
    animal.toString();//会输出A

• 在父类对象为Null的情况下

    var animal  = Object.Create(Animal);     
    animal.toString = function(){
        return 'A';
    }
    document.write(animal);//隐式调用了toString方法

Call/apply

• 作用：改变this指向

    function Person(name){//类似与工厂
    this.name = name;
    }
    var person =new Person('test');
    var obj ={};
    Person.call(obj,'obj_test');//将this 从Person转为obj，类似借用工厂
    person.name ;//会输出obj_test

• 作用：继承

    function Person(name,tel){//类似与工厂
    this.name = name;
    this.tel =tel;
    }
    function Student(name,age,tel){
        Person.call(this,name,tel);//使用工厂(继承父类变量，用自己进行实现)
        Person.apply(this,[name,tel]);//与call等价
        this.age = age;
    }
    var student=new Student('test01',"test02","test03");

• 区别(call/apply)：apply需要传数组，call需要按形参个数对应传入

继承

---

1. 传统模式(原型链)

• 缺点：过多的继承没用的属性

2. 借用构造函数

• 缺点1.不能继承借用构造函数的原型
• 缺点2. 每次构造函数多进行一步函数

3. 共享原型（inherit,extend）

• 缺点：不能随便修改自己的原型(两个及其以上的类指向了同一个原型) Son-->Father

4. 圣杯模式

• 原理：利用原型链，在共享原型基础上，添加一个类，修改每一个原型
• 构成原型链 Son-->Middle(中间类)-->Father
• 查询Constuctor :Son.constuctor-->Father

    function inherit(target,origin){//类似与工厂
      function Middle(){};//中间类
      Middle.prototype = origin.prototype;
      target.prototype = new Middle();
      target.constuctor = target;
      target.prototype.uber = origin.prototype;//存储真正的 父类
    }
    function Father(){     
    }
    function Son(){     
    }
    inherit(Son,Father);//必须在new之前
    var son=new Son();

• 由于Middle是起过渡作用，所以对其进行可以采用闭包进行优化

    function inherit(target,origin){
      var Middle =  function (){};//闭包起到私有化作用
      return function(target,origin){
          Middle.prototype = origin.prototype;
          target.prototype = new Middle();
          target.constuctor = target;
          target.prototype.uber = origin.prototype;
      }
    }
    function Father(){     
    }
    function Son(){     
    }
    inherit(Son,Father);//必须在new之前
    var son=new Son();