js总结 （5）原型 原型链,,,继承的问题

1.简单理解：原型是属于对象的一个属性，他们又公共祖先，可以继承祖先的属性，原型本身也是对象

  一个对象 有一个祖先，这个祖先有的东西 儿子孙子 都可以继承拿去用，但是儿子孙子不能修改，如果要修改添加 要到祖先这边来修改

以下案例展示原型和原型链

Person.prototype.name = 'abc';
functon Person() {
//var this = ｛
//
// __proto__:Person.prototype //本来__proto__是函数里面的隐式属性，其原型为Person.prototype，继承的name属性为'abc'
//｝
var obj = {
name : "sunny"
}
var person = new Person();

其实就是 person.__proto__=Person.prototype;
下面你把别的函数赋值给 person.__proto__ 和 Person.prototype的结果是一样的

// Grand.prototype.__proto__=Object.prototype;  最终原型
Grand.prototype.LastName ="MrZhang"; 
    function Grand() {
     this.car="BMW"
    }
    var grand=new Grand();

    Father.prototype=grand;    // 父亲的prototype 指向爷爷
    function Father() {
      this.money="90";
    }
    var father=new Father();

    Son.prototype=father;    // 儿子的prototype 指向父亲
    function Son() {
     this.age=1;
    }
    var son=new Son();

绝大多数对象的最终都会继承自Object.prototype

• 对象的原型只能是一个object或null，但null没有原型，也没有proto属性
• 原型类属性是系统内部属性，自己加是不管用的
• // var obj = Object.create(原型）；
  var obj = {name : "sunny",age : 123}; var obj1 = Object.create(obj);

2.继承：

1.传统形式 –>原型链 
- 过多继承了没用的东西 

2.借用构造函数 –>call/apply 
- 不能继承借用构造函数的原型，原型还是自己的 
- 每次构造函数都要多走一个函数，造成运行复杂 

3.共享原型 
- 不能随便改动自己的原型,不能实现自己个性化的原型 

示例：

<script type = "text/javascript"> 
    Father.prototype.lastName = "Deng";
    function Father（）{
    }
    function Son() {
    }
    function inherit(Target,Origin) {
        Target.prototype = Origin.prototype;
    }

    inherit(Son,Father);
    Son.prototype.sex = "male";         //此时给Son添加一个属性，这个属性也会添加到Father上
    var son = new Son();                //因为此时他俩指向同一个原型，所以我们说不能实现元素的个性化设计
    var father = new Father();
</script>

<script type = "text/javascript"> 
    function inherit(Target,Origin)｛
        function F() {
        F.prototype = Father.prototype;
        Target.prototype = new F();
        Target.prototype.constructor = Target;
        Target.prototype.uber = Target;   //构造对象的超类（真正继承自谁）
    ｝
    Father.prototype.lastName = "Deng";
    function Father(){
    }
    function Son() {
    }
    inherit(Son,Father);
    var son = new Son();
    var father = new Father();
</script>

4.圣杯模式

1.传统写法

 Father.prototype
    function F() {}
    F.prototype = Father.porotype 
    Son.prototype = new F();   //这时先继承再生成新的new，又满足了继承，又不会互相干扰

示例

<script type = "text/javascript"> 
    function inherit(Target,Origin)｛
        function F() {
        F.prototype = Father.prototype;
        Target.prototype = new F();
        Target.prototype.constructor = Target;
        Target.prototype.uber = Target;   //构造对象的超类（真正继承自谁）
    ｝
    Father.prototype.lastName = "Deng";
    function Father(){
    }
    function Son() {
    }
    inherit(Son,Father);
    var son = new Son();
    var father = new Father();
</script>

2.雅虎写法

var inherit =(function () {
   var F = function () { };
   return function (Target,Origin) {
       F.prototype=Origin.prototype;
       Target.prototype = new F();
       Target.prototype.constructor=Target;
       Target.prototype.uber=Origin.prototype;
   }
}());
 function Father() {         
     }
     function Son() {         
     }
 inherit(Son,Father);
  
    Son.prototype.color="red"
   var son=new Son();
   var father=new Father();