1.用原型链实现继承 最普通 但是没有办法传参，没有办法共享方法

继承是面向对象中一个比较核心的概念。其他正统面向对象语言都会用两种方式实现继
承：一个是接口实现，一个是继承。而 ECMAScript 只支持继承，不支持接口实现，而实现
继承的方式依靠原型链完成。

原型链是由原型加对象构造之间的关系结构形成的像一个链条一样

在 JavaScript 里，被继承的函数称为超类型(父类，基类也行，其他语言叫法)，继承的
函数称为子类型(子类，派生类)。

//继承，通过原型链实现

function Box() { //Box 构造 被继承的函数叫做超类型（父类）
this.name = ‘Lee‘;
}
function Desk() { //Desk 构造 继承的函数称为子类型(子类，派生类)。
this.age = 100;
}

var desk = new Desk();

alert(desk.age); 　　//100

alert(desk.name); 　　//undefined  

//通过原型链继承，超类型实例化后的对象实例，赋值给子类型的原型属性即可

//new Box()会将Box构造里的信息和原型里的信息都交给Desk
Desk.prototype = new Box(); //Desk 继承了 Box，通过原型，形成链条  超类型new出来的东西交给子类型的原型
var desk = new Desk();
alert(desk.age);
alert(desk.name); // Lee 得到被继承的属性

function Table() { //Table 构造
this.level = ‘AAAAA‘;
}
Table.prototype = new Desk(); //继续原型链继承
var table = new Table();
alert(table.name); //Lee  继承了 Box 和 Desk

Desk的原型得到的是Box的构造加原型里的信息（图中水平第一个和第二个框），Table的原型又得到了Desk的构造和原型里的信息，所以最终的  Table得到了上面所有的信息。

如果要实例化 table，那么 Desk 实例中有 age=100，原型中增加相同的属性 age=200，
最后结果是多少呢？
Desk.prototype.age = 200; //实例和原型中均包含 age

alert(table.age);　　//输出100  就近原则  实例里面有就返回，没有就去查找原型

从属关系

以上原型链继承还缺少一环，那就是 Obejct，所有的构造函数都继承自 Obejct。而
继承 Object 是自动完成的，并不需要程序员手动继承。

//子类型从属于自己或者他的超类型

alert(desk instanceof Desk);　　//true
alert(desk instanceof Box);　　//true

alert(desk instanceof Object);　　//true

继承也有之前问题，比如字面量重写原型会中断关系，使用引用类型的原型时，并且子类型还无法给超类型传递参数。

2.第二种继承方法——借用构造函数继承 即对象冒充继承 解决了传参的问题  但是没有解决共享的方法

为了解决引用共享和超类型无法传参的问题，我们采用一种叫借用构造函数的技术，或
者成为对象冒充(伪造对象、经典继承)的技术来解决这两种问题。

//使用对象冒充

function Box(name,age) {
this.name = name;
this.age = age;

}

Box.prototype.family=‘家庭‘;
function Desk(name,age) {
Box.call(this, name,age); //this代表了Desk本身的类   对象冒充，给超类型传参 因此 Desk就可以冒充Box了 对象冒充只能继承构造里的信息，继承不了原型里的信息

}

var desk = new Desk(‘Lee‘,100);

alert(desk.name);　　//输出 Lee   说明Desk冒充了Box

alert(desk.family);　　//undefined   原型里的信息继承不过来

//引用类型放到构造函数里就不会共享

function Box(name,age) {
this.name = name;
this.age = age;

this.family = [‘哥哥‘,‘姐姐‘,‘妹妹‘];

}

function Desk(name,age){

Box.call(this,name,age);

}

var desk = new Desk(‘Lee‘,100);

desk.family.push(‘弟弟‘);

alert(desk.family);　　//输出 哥哥 姐姐 妹妹 弟弟

var desk2 = new Desk(‘Lee‘,100);

alert(desk2.family);　　//输出  哥哥 姐姐 妹妹  引用类型放到构造函数里就不会共享

（参看面向对象与原型4---原型）

function Box(name,age) {
this.name = name;
this.age = age;

this.family = [‘哥哥‘,‘姐姐‘,‘妹妹‘];

this.run = function(){

}

}

function Desk(name,age){

Box.call(this,name,age);

}

var desk = new Desk(‘Lee‘,100);

var desk2 = new Desk(‘Lee‘,100);

//构造函数里的方法，放在构造里，每次实例化都会分配一个内存地址，浪费，所以最好放在原型里，保证多次实例化只有一个地址。

function Box(name,age) {
this.name = name;
this.age = age;

this.family = [‘哥哥‘,‘姐姐‘,‘妹妹‘];

}

Box.prototype.run = function(){

　　return this.name+this.age;

}

function Desk(name,age){

Box.call(this,name,age);

}

var desk = new Desk(‘Lee‘,100);

var desk2 = new Desk(‘Lee‘,100);

以上两次实例化保证了一个地址

但是

alert(desk.run());　　//not a function  因为通过对象冒充继承不到原型里的东西

3.组合模式实现继承（结合前两种）----最常用

对象冒充 结合 原型链  解决传参和方法共享的问题
借用构造函数虽然解决了刚才两种问题，第一个：引用保持独立。第二个：可以传参。但没有原型，复用则无从谈起。所以，我们需
要原型链+借用构造函数的模式，这种模式成为组合继承。

function Box(name,age) {
this.name = name;
this.age = age;

this.family = [‘哥哥‘,‘姐姐‘,‘妹妹‘];

}

Box.prototype.run = function(){

　　return this.name+this.age;

}

function Desk(name,age){　　

Box.call(this,name,age);　　//对象冒充只继承构造里的

}

Desk.prototype = new Box();　　//原型链继承  只继承原型里的

4.原型式继承

还有一种继承模式叫做：原型式继承；这种继承借助原型并基于已有的对象创建新对象，
同时还不必因此创建自定义类型。

//临时中转函数

function obj(o){　//o表示将要传递进入的一个对象实例　

　　function F(){}　　//F构造是一个临时新建的对象，用来存储传递进来的对象

　　F.prototype=o;　　//将o对象实例赋值给F构造的原型

　　return new F();　　//　最后返回这个得到传递过来对象的对象实例

}

var box={　　//这是字面量的声明方式，相当于 var box=new Box();

name:‘Lee‘,

age:100,

family:[‘哥哥‘,‘姐姐‘,‘妹妹‘]

}

var box1=obj(box);　　//box1就等于new出来的F

alert(box1.name);　　//Lee

box1.family.push(‘弟弟‘);

alert(box1.family);　　//哥哥姐姐妹妹弟弟

var box2=obj(box);

alert(box2.family);　　//哥哥姐姐妹妹弟弟 引用类型的属性共享了  因为把box全部放到F.prototype里了

标题说的原型式继承实际上是F继承了box   F.prototype=o 其实就相当于Desk.prototype= new Box()

这种方法其实就是原型链继承 意思是一样的  只不过是改写了方式

5.寄生式继承 =原型式+工厂模式  ，目的是为了封装创建对象的过程

//临时中转函数

function obj(o){　//o表示将要传递进入的一个对象实例　

　　function F(){}　　//F构造是一个临时新建的对象，用来存储传递进来的对象

　　F.prototype=o;　　//将o对象实例赋值给F构造的原型

　　return new F();　　//　最后返回这个得到传递过来对象的对象实例

}

//寄生函数

function create(o){

var f=obj(o);

f.run = function(){

　　return this.name;

}

return f;

}

var box={　　//这是字面量的声明方式，相当于 var box=new Box();

name:‘Lee‘,

age:100,

family:[‘哥哥‘,‘姐姐‘,‘妹妹‘]

}

var box1=create(box)；

alert(box1.name);

alert(box1.run());//Lee

组合式继承是 JavaScript 最常用的继承模式；但，组合式继承也有一点小问题，就是超
类型在使用过程中会被调用两次：一次是创建子类型的时候，另一次是在子类型构造函数的
内部。

function Box(name) {
this.name = name;
this.arr = [‘哥哥‘,‘妹妹‘,‘父母‘];
}
Box.prototype.run = function () {
return this.name;
};
function Desk(name, age) {
Box.call(this, name); //第二次调用 Box
this.age = age;
}
Desk.prototype = new Box(); //第一次调用 Box
以上代码是之前的组合继承，那么寄生组合继承，解决了两次调用的问题。

6.寄生组合继承

//临时中转函数

function obj(o){　

　　function F(){}　　

　　F.prototype=o;　　

　　return new F();　　

}

//寄生函数

function create(box,desk){

var f=obj(box.prototype);　　//调用obj函数

f.constructor= desk;　　//调整原型构造指针

desk.prototype =f;

}

function Box(){

　　this.name=name;

　　this.age=age;

}

Box.prototype.run=function(){

　　return this.name+this.age;　　//方法放在原型 让每次实例化的时候 地址保持一致

}

function Desk(name,age){

Box.call(this,name,age);

}

//通过寄生组合继承来实现继承

create(Box,Desk);　　//这句话用来替代Desk.prototype=new Box();

var desk = new Desk(‘Lee‘,100);

alert(desk.run());　　//Lee100