javaScript基础：继承

一、简介

继承是面向对象中一个比较核心的概念。

其他正统面向对象语言都会用两种方式实现继承:一个是接口实现,一个是继承。

而ECMAScript只支持继承,不支持接口实现。

二、实现继承-原型链

1、代码

//定义一个父类
function Father (money){
 this.money = money;
}

//定义一个子类
function Son (age){
 this.age = age;
}


/*说明：
new Father ();新创建一个Father类型的实例对象，这个实例对象包含了Father类的原型对象信息和构造函数信息。
将新创建的这个心对象赋值给Son类型的原型对象，相当于所有的Son类型的实例在创建时都包含了Father类型的原型对象信息、构造函数信息、还有自身的构造函数信息。
以上通过设置原型对象属性的方法完成了继承关系，这种方式叫做原型链。
 */
Son.prototype = new Father(1000);//此行代码就完成了子类继承父类</span>

var son = new Son(18);//创建一个子类实例对象
alert(son.money);//1000 子类实例对象具有money属性。

2、从属关系

//从属关系：所有的对象都从属于Object类型
//子类从属与父类
var father = new Father();
var son = new Son();
alert(father instanceof Object);//true
alert(son instanceof Object);//true
alert(son instanceof Father);//true
alert(father instanceof Son);//false

3、就近原则

当一个类型中的父类有属性A，而子类的构造函数中也有属性A时，应当取父类的A属性还是子类的属性A；

每个对象都有一个构造函数和原型对象，当构造函数和原型对象里具有一个同名的属性时，系统会先在构造函数里查找，有的话直接返回，没有的话再去原型对象里寻找。这就是所谓的就近原则，也更好的实现了共享与自身的灵活性。换句话说就是自己有的东西就不去原型那里取，自己没有就去找原型要，原型也没有就彻底没有了。

子类继承父类，继承的父类的构造函数和原型对象。将父类的构造函数和原型对象作为子类的原型对象，所以当子类的构造函数里有属性A就直接返回，没有的话就去自己的原型对象取，也就是父类里取。所以继承关系也符合就近原则。

//定义一个父类
function Father (){
 this.money = 1000;
}

//定义一个子类
function Son (){
 this.money = 2000;
 this.age = 18;
}
Son.prototype = new Father();
var son = new Son();
alert(son.money);//2000 自己有就不会取父类里的money

4、存在问题

通过原型链实现继承存在问题：

第一个：子类的prototype是父类的一个实例对象，存储的信息是固定的。不能从子类进行传参。

第二个：字面量重写原型会中断关系。Son.prototype = new Object();重写后断开继承关系 

三、实现继承-对象冒充

1.代码

//定义一个父类
function Father (money){
 this.money = money;
}

//定义一个子类
function Son (money,age){
 // 个人觉得：
 // 此处是当普通函数使用的。
 // 使用对象冒充之后Son的实例对象可以调用Father这个方法
 // 调用Father方法之后实例对象就增加了money属性。也就相当于从父类继承来了money属性，并且参数是子类传的。
 Father.call(this,money);
 this.age = age;
}

var son = new Son(1000,18);
alert(son.money);//1000
alert(son.age);//18

2.存在问题

借用对象冒充虽然解决了刚才两种问题,但没有原型,复用则无从谈起。所以,我们需要 原型链+对象冒充 的模式,这种模式成为组合继承。 

四、原型链+对象冒充

//定义一个父类
function Father (money){
 this.money = money;
}
Father.prototype.run = function (){
 return '这是父类方法....';
};

//定义一个子类
function Son (money,age){
 Father.call(this,money);
 this.age = age;
}

Son.prototype = new Father();//个人觉得应该加上：Son.prototype.constructor = Son;这行代码
//个人觉得：对象冒充使子类有了一个money属性，而原型链也使子类有了一个money属性，只不过这个money属性是存在原型对象里，会就近原则被隐藏掉。
var son = new Son(1000,18);
alert(son.money);//1000
alert(son.age);//18
alert(son.run());//这是父类方法...

五、组合模式

//临时中转函数
function obj(o) {				
	function F() {}				
	F.prototype = o;			
	return new F();			
}


//完成继承关系。要想在子类的原型对象里增加新的属性可以在这个方法内完成。个人觉得：也可以在中转函数中完成
function create(Father, Son) {
	var f = obj(Father.prototype);
	f.constructor = Son;				//调整原型对象的构造指针
	son.prototype = f;
}
//定义父类型
function Father(name, age) {
	this.name = name;
	this.age = age;
}

Father.prototype.run = function () {
return this.name + this.age + '运行中...'
}
function Son(name, age) {
    Father.call(this, name, age); //
}
//创建对象
create(Father, Son); //创建继承关系的函数
var son = new Son('Lee', 100);
alert(son.run());
alert(son.constructor);