JS原型以及继承机制

1. 对象如何创建？
   ans：通过构造函数模式与原型模式相结合。利用构造函数模式定义实例属性，利用原型模式定义方法和共享属性。如下代码所示：

function Person() {
     this.friends = ["Haier", "John"];
}
Person.prototype.species =  "人类";
Person.prototype.habbit = function() {
     alert("打篮球");
}
var person1 = new Person();
var person2 = new Person();
person1.friends.push("Anna");
alert(person1.friends);  // ['Haier', 'John', 'Anna' ]
alert(person2.friends);  //  [ 'Haier', 'John' ]

2. 创建的对象实例的特点
   ans：(1) 每个实例都有一个prototype(原型)属性，这个属性是一个指针，指向构造函数的原型对象，这个对象包含可以被构造函数的所有实例共享的属性和方法。

console.log(person1._proto_ === Person.prototype);    // true

(2) 每个原型对象都会默认取得constructor属性，对象实例的constructor属性，实际上是从原型对象继承的，属于原型属性，不属于本地属性(即在构造函数中定义的)
(3) 对于原型对象中的值，可以通过对象实例访问，但不能通过对象实例重写，若在对象实例中添加一个属性，与原型对象中的属性同名，则该属性会在实例中被创建，这个添加的属性会阻止我们访问原型对象中的同名属性，但是不会修那个属性。可以通过delete来删除实例中的这个属性，从而可以继续访问原型对象中的属性。

3. 什么是原型链？
   ans：在js中，所有对象都有原型对象（prototype）。一方面，任何一个对象，都可以作为其他对象的原型，而原型对象作为一个对象，也有自己的原型对象。因此会形成一个原型链：对象到原型，原型到原型…
   所有对象的原型都可以上溯到Object.prototype，而Object.prototype的原型为null，null没有任何属性和方法，也没有自己的原型，所以原型链的尽头就是null

4. js如何实现继承？
   ans：
   （1）构造继承
   代码：

function SuperType() {
    this.colors = ["red","blue"];
}
function SubType() {
    SuperType.call(this);
};
var instance1 = new SubType();
instance1.colors.push("yellow");
console.log(instance1.colors); // [ 'red', 'blue', 'yellow' ]
var instance2 = new SubType();
console.log(instance2.colors);  // [ 'red', 'blue']

如上述代码所示，通过构造函数继承，即在SubType()中调用SuperType()。其缺陷在于，在SuperType的原型中定义的方法，对于SubType是不可见的。但是构造函数模式最大的优势在于，可以传递参数 ，见代码：

function SuperType(name) {
    this.name = name;
}
function SubType() {
    SuperType.call(this, "Nicholas"); // 继承SuperType，同时传递参数
    this.age = 29;  // 实例属性
};
var instance = new SubType();
console.log(instance.name);  // "Nicholas"
console.log(instance.age);    // 29

（2）原型继承
代码：

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

SubType.prototype = new SuperType();

var instance1 = new SubType();
instance1.colors.push("yellow");
console.log(instance1.colors); // [ 'red', 'blue', 'yellow' ]
var instance2 = new SubType();
console.log(instance2.colors);  // [ 'red', 'blue', 'yellow' ]

如代码中所示 ，利用原型链实现继承时，包含引用类型值的原型属性会被所有实例共享，上述代码相当于在SubType的原型属性上定义了一个会被所有实例共享的colors属性，从对instance1.colors属性的修改反映在instance2.colors属性上可以看出。
另外一个问题是，在创建SubType类型的实例时，不能向SuperType的构造函数中传递参数。
（3）实例继承

（4）拷贝继承

实际上，我们最常用的是组合继承， 即通过原型链继承来继承共享的属性和方法，借用构造函数来继承实例属性。见代码：

function SuperType(name) {
     this.name = name;
     this.colors = ["red", "blue"];
 }
 SuperType.prototype.sayName = function() {
     console.log(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() {
     console.log(this.age);
 }
 var instance1 = new SubType("Nicholas", 29);
 instance1.colors.push("yellow");
 console.log(instance1.colors);  //[ 'red', 'blue', 'yellow' ]
instance1.sayName();  // "Nicholas"
instance1.sayAge();    // 29

var instance2 = new SubType("Greg", 30);
console.log(instance2.colors);  // [ 'red', 'blue' ]
instance2.sayName();     // "Greg"
instance2.sayAge();      // 30

如代码所示，两个SubType实例既具有自己的属性，又可以使用相同的方法。
继承方法的语句也可以写成：

/* SubType.prototype = new SuperType();   // 继承方法 */
 SubType.prototype = Object.create(SuperType.prototype);

因为上面一行的写法，相当于调用了两次SuperType构造函数，第一次调用时SubType.prototype具有colors和name属性，第二次调用时，SubType具有实例属性colors和name，屏蔽了原型中的同名属性。