创建对象及继承

组合使用构造函数模式和原型模式

构造函数模式：即在子类型构造函数中调用父类型的构造函数。 利用apply（）和call方法（）可以像创建内置对象实例一样使用new操作符，缺点：它的每个成员无法得到复用。

原型模式：使用构造函数的prototype属性制定那些应该共享的属性和方法。

组合使用构造函数模式和原型模式：使用构造函数定义实例属性，使用原型定义共享的属性和方法。

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["jay","elva","britney"];
}
Person.prototype = {
    constructor : Person,
    sayName : function(){
        alert (this.name);
    }
}
person1 = new Person("aa",18,"student");
person2 = new Person("bb",68,"teacher");
person1.friends.push("angel");
alert(person1.friends);//"jay","elva","britney"
alert(person2.friends);//"jay","elva","britney","angel"
alert(person1.friends === person2.friends);//false,不同数组
alert(person1.sayName());//aa
alert(person2.sayName());//bb
alert(person1.sayName() === person2.sayName());//true，同一函数

说一说prototype原型对象

一个对象的原型是它的构造函数的prototype属性的值。所有函数都有一个prototype属性，当一个函数被定义的时候，prototype属性会被自动创建和初始化。prototype属性的初始值是一个对象，而这个对象只带一个属性，而这个属性名为constructor，即构造函数。在prototype对象中，还可以为其添加其他的属性。给这个原型对象添加的任何属性，都会成为被构造函数所初始化的对象的属性。

new一个构造函数 –创建空对象 –设置对象的原型prototype
–prototype的属性自动创建并初始化 –初始化空对象的属性

最常用的继承方法—-组合继承

思路：使用原型链实现对原型属性和方法的继承，通过借用构造函数来实现实例属性的继承。
好处：既通过在原型上定义方法实现函数复用，又保证每个实例都有它自己的属性。

function SuperType(name){
    this.name = name;
    this.colors = ["red","yellow"];
}
SuperType.prototype.sayName = function(){
    alert(this.name);
};
function SubType(name,age){
    SuperType.call(this,name);//继承属性
    this.age = age;
}
//继承方法
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
    alert(this.age);
};
var v1 = new SubType("jay",19);
v1.colors.push("black");
alert(v1.colors);//"red","yellow","black"
v1.sayAge();//19
v1.sayName();//"jay"
var v2 = new SubType("elva",44);
alert(v2.colors);//"red","yellow"
v2.sayAge();//44
v2.sayName();//elva

组合继承：存在的问题：需要调用两次福类型构造函数，对此是创建子类型原型的时候，第二次是在子类型的构造函数内部。

继承最有效的方式—-寄生组合式继承

思路：不必为了为了制定子类型的原型而调用父类型的构造函数，我们需要的只是父类型原型的一个副本而已。
方法：通过构造函数继承属性，通过原型链混成形式来继承方法。
基本模式：

function inheritPrototype(subType,superType){
    var prototype = Object(superType.prototype);//创建超类型的一个副本对象
    prototype.constructor = subType;//为创建的副本增加constructor属性
    subType.prototype = prototype;//将第一步创建超类型的一个副本对象赋值给子类型的原型
}

function SuperType(name){
    this.name = name;
    this.colors = ["red","yellow"];
}
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);
};

采用寄生组合式继承，高效率，只调用一次SuperType构造函数。因此为最佳继承方式。