javascript继承

1.ECMAScript只支持继承，不支持接口实现，而实现继承的方式依靠原型链完成

//继承，通过原型链实现
function Box(){//被继承的函数叫做超类型（父类，基类）
	this.name = 'Lee';
}
function Desk(){//继承的函数叫做子类型（子类，派生类）
	this.age = 100;
}
function Table(){
	this.level = 'AAAAA';
}
Desk.prototype = new Box();
Table.prototype = new Desk();
var box = new Box();
console.log(box.constructor);
var desk = new Desk();
console.log(desk.name);//Lee
console.log(desk.age);//100
var table = new Table();
console.log(table.name);//Lee
console.log(table.age);//100
console.log(table.level);//AAAAA

2.关于构造函数和原型中的属性谁先谁后的问题

就近原则，实例里有，就 返回，没有就去查找原型

//继承，通过原型链实现
function Box(){//被继承的函数叫做超类型（父类，基类）
	this.name = 'Lee';
}
Box.prototype.name = 'Jack';
function Desk(){//继承的函数叫做子类型（子类，派生类）
	this.age = 100;
}
Desk.prototype = new Box();
var box = new Box();
console.log(box.constructor);
var desk = new Desk();
console.log(desk.name);//Lee 就近原则，实例里有，就 返回，没有就去查找原型
console.log(desk.age);//100
//子类型从属于自己或者他的超类型
console.log(desk instanceof Object);//true
console.log(desk instanceof Desk);//true
console.log(desk instanceof Box);//true
console.log(box instanceof Desk);//false Box是Desk的超类

3.使用对象冒充继承解决引用共享和超类型无法传参的问题

//使用对象冒充继承解决引用共享和超类型无法传参的问题
function Box(name,age){
	this.name = name;
	this.age = age;
	this.family = ['哥哥','姐姐','妹妹'];//引用类型，放在构造里就不会被共享
}
Box.prototype.family = '家庭';//被短路，直接调用构造函数中的同名属性
function Desk(name,age){
	Box.call(this, name,age);//对象冒充，对象冒充只能继承构造里的信息
}
var desk = new Desk('Lee',100);
console.log(desk.family);
desk.family.push('弟弟');
console.log(desk.family);
var desk2 = new Desk('Lee',100);
console.log(desk2.family);

4.借用构造函数解决了引用共享和超类型无法传参的问题，为实现复用要使用原型，进而使用组合继承

组合继承=原型链+借用构造函数

//组合继承=原型链+借用构造函数，解决使用原型实现复用
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();//原型链继承
var desk = new Desk('Lee',100);
console.log(desk.run());

5.还有一种继承模式叫原型式继承，这种继承借助原型并基于已有的对象创建新对象

//原型式继承
//临时中转函数
function obj(o){//o表示要传递进入的一个对象
	function F(){}//F构造是一个临时新建的对象，用来存储传递过来的对象
	F.prototype = o;//将o对象实例赋值给F构造的原型对象
	return new F();//最后返回这个得到传递过来对象的对象实例
}
var box = {
		name:'Lee',
		age:100,
		family:['哥哥','姐姐','妹妹']
};
var box1 = obj(box);
console.log(box1.name);
console.log(box1.age);
console.log(box1.family);
box1.family.push('弟弟');
console.log(box1.family);
var box2 = obj(box);
console.log(box2.family);//引用类型的属性共享了

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

//寄生式继承=原型式+工厂模式,目的是为了封装创建对象的过程
//临时中转函数
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 = {
		name:'Lee',
		age:100,
		family:['哥哥','姐姐','妹妹']
};
var box1 = create(box);
console.log(box1.run());

7.组合继承=原型链+借用构造函数，解决使用原型实现复用，但存在问题。
组合式继承在使用过程中会被调用2次：一次是创建子类型的时候，另一次是在子类型构造函数的内部。

//组合继承=原型链+借用构造函数，解决使用原型实现复用
//组合式继承在使用过程中会被调用2次：一次是创建子类型的时候，另一次是在子类型构造函数的内部
function Box(name,age){
	console.log('Box被调用');
	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);//第二次调用Box
}
Desk.prototype = new Box();//第一次调用Box
var desk = new Desk('Lee',100);
console.log(desk.run());

8.寄生组合继承解决了2次调用的问题

//寄生组合继承解决了2次调用的问题
//临时中转函数
function obj(o){//o表示要传递进入的一个对象
	function F(){}//F构造是一个临时新建的对象，用来存储传递过来的对象
	F.prototype = o;//将o对象实例赋值给F构造的原型对象
	return new F();//最后返回这个得到传递过来对象的对象实例
}
//寄生函数
function create(box,desk){//封装创建过程
	var f = obj(box.prototype);
	f.constructor = desk;//调整原型构造指针
	desk.prototype = f;
	return f;
}
function Box(name,age){
	console.log('Box被调用');
	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);//对象冒用
}
//通过寄生组合继承来实现继承
create(Box,Desk);
var desk = new Desk('Lee',100);
console.log(desk.run());
console.log(desk.family);
desk.family.push('妹妹');
console.log(desk.family);
var desk2 = new Desk('Jack',200);
console.log(desk2.run());//只共享了方法
console.log(desk2.family);//引用问题解决

以上就是javascript中关于继承的内容，每种继承都有自己的优点和缺点，都有自己的适用场合，需要我们根据不同的使用需求进行灵活选用。