面向对象的程序设计 <step 4 ~ 继承>

大家好，我是苏日俪格，本文是面向对象的第四部分，纯属个人理解，有哪里不对的地方请在评论区指出，大家一起学习共同进步。

下面来看一下对象继承都有哪些方式：

原型链式继承：

原型链是面向对象中最常见最简单的，所谓原型链就是用父类实例来充当子类原型的对象
直接走栗子：
<br> 111<br>

function Father(){
	this.aInfo = ['苏日俪格', 'web前端开发'];
}
function Child(){}
Child.prototype = new Father();
let child = new Child();
console.log(child.aInfo)	// ["苏日俪格", "web前端开发"]

child.aInfo.push(24);
console.log(child.aInfo)	// ["苏日俪格", "web前端开发", 24]

let child2 = new Child();
console.log(child2.aInfo)	// ["苏日俪格", "web前端开发", 24]

优点：简单易懂
缺点：由于这种原型链式继承实例之前共享了属性，所以在修改属性值的时候是存在引用的；还有个问题就是在创建实例的时候，无法给父类型构造函数中传递参数，因此一般不单独用原型链

这个时候面向对象的老板娘来了，笑着对大佬说了一句，想加薪不，想的话就加一下班处理一下，于是乎大佬们研究出了借用构造函数的继承方式 ↓↓↓

借用构造函数：

鉴于原型链的问题，就出现了借用构造函数的方式，就是在子类型的构造函数中调用超类型的构造函数，来实现继承，在调用的过程中，需要用apply或call方法来改变this的指向问题

无参数构造函数：

function Father(){
	this.aInfo = ['苏日俪格', 'web前端开发'];
}
function Child(){
	Father.call(this);
}
Child.prototype = new Father();
let child = new Child();
console.log(child.aInfo)	// ["苏日俪格", "web前端开发"]

child.aInfo.push(24);
console.log(child.aInfo)	// ["苏日俪格", "web前端开发", 24]

let child2 = new Child();
console.log(child2.aInfo)	// ["苏日俪格", "web前端开发"]

有参数构造函数：

function Father(name){
	this.aInfo = name;
}
function Child(age){
	Father.call(this, ['苏日俪格', 'web前端开发']);
	this.age = age;
}
Child.prototype = new Father();
let child = new Child(24);
console.log(child.aInfo)	// ["苏日俪格", "web前端开发"]
console.log(child.age)	// 24

优点：解决了原型链式存在的问题
缺点：代码复用性差，函数复用没办法解决，如果子类型构造函数过多，会导致内存泄漏的问题，因此这种方式也很少单独使用

这个时候面向对象的老板娘她又来了，面带不太自然的微笑刚准备开口说话，大佬说我加一下班处理一下，于是乎大佬们又研究出了组合继承的继承方式 ↓↓↓

组合继承

这就和创建对象时候使用的混合模式其实是一个道理，就是将原型链和借用构造函数结合，发挥二者的优点取长补短，实现共享方法不共享属性

function Person(name){
	this.aInfo = name;
}
Person.prototype.show = function(){
	console.log(this.aInfo);
};
function Child(name, age){
	Person.call(this, name);
	this.age = age;
}
Child.prototype = new Person();
Child.prototype.constructor = Child;
Child.prototype.showAge = function(){
	console.log(this.age);
};

let child1 = new Child(['苏日俪格', 'web前端开发'], 24);
child1.show();	// ["苏日俪格", "web前端开发"]
child1.aInfo.push('男');
child1.show();	// ["苏日俪格", "web前端开发", "男"]
child1.showAge();	// 24

let child2 = new Child(['赵云', '救阿斗'], 27);
child2.show();	// ["赵云", "救阿斗"]
child2.showAge();	// 27

优点：融合二者优点于一身，也是最常用的一种继承方式
缺点：虽然是最常用的一种继承方式，但是也有一丢丢瑕疵，就是无论什么情况下，都会调用两次超类型构造函数，在第一次call的时候，把父类型的实例属性拷贝了一份给子类实例属性，而这个属性根本就是活着浪费空气死了浪费土地型的，因此导致的原型引用属性在实例间共享；不过到这里，其实能感觉到就是一个小瑕疵，所以一般码农门也不会考虑它，毕竟相对于这一丁点劣势还是值得的。

这个时候面向对象的老板娘她还是来了，阴险的笑容马上就漏出来了，于是大佬们冷静的喝了一杯茶，回过头还是研究出了最佳的继承方式，就是寄生组合式继承法，这个方法也是目前的终极版了，各种优点体现的淋漓尽致，但是也有一个缺点就是理解起来编程的过程中有些复杂，别问我，因为我不想加薪(’ｰ’)，所以就没看，想看的自己去问度娘吧(～￣▽￣)～

本文的所有内容均是一字一句敲上去的，希望大家阅读完本文可以有所收获，因为能力有限，掌握的知识也是不够全面，欢迎大家提出来一起分享！谢谢O(∩_∩)O~