JS继承的几种实现方式
继承是指子类继承父类的属性和方法，要实现继承，首先我们需要有一个父类
function Person (name){
//属性
this.name = name || 'person';
this.firends = ['James','Curry'];
//方法
this.speak = function (){
console.log('I can speak chinese!')
}
}
//原型方法
Person.prototype.skill= function (){
console.log('running')
}
var person = new Person;
person.speak(); //"speak"
person.skill(); //"running"
原型链继承
原型链继承的本质就是就是将父类的实例作为子类的原型对象
function Chinese() {
}
//继承Person
Chinese.prototype = new Person;
Chinese.name = "lianqi";
//添加新方法
Chinese.prototype.speakChinese = function (){
console.log('speak chinese')
}
//重写父类中的方法
Chinese.prototype.skill = function (){
console.log('jump')
}
console.log(chinese.name); //"lianqi"
chinese.speak(); //"speak"
chinese.speakChinese(); //"speak chinese"
chinese.skill(); //"jump"
console.log(chinese instanceof Chinese); //true
console.log(chinese instanceof Person); //true
子类有时需要重写父类中某个方法，或者需要添加子类中不存在的方法。不管怎么样给原型添方法的代码，一定要放在替换原型的语句之后。
还有一点需要注意，再通过原型链来实现继承时不能使用对象字面量创建原型方法，因为这样做会重写原型链，就不能调用父类的方法。如下面的例子
function Chinese() {
}
Chinese.prototype = {
eat : function (){
console.log('eat food')
}
}
var chinese = new Chinese();
console.log(chinese instanceof Chinese); //true
console.log(chinese instanceof Person); //false
chinese.eat(); //"eat food"
chinese.speak(); //报错"chinese.speak is not a function"
原型链虽然很强大，可以用它来实现继承，但也存在一些问题：
1.重写子类的原型 等于 父类的一个实例，（父类的实例属相变成子类的原型属性）如果父类包含引用类型的属性，那么子类所有实例都会共享该属性（包含引用类型的原型属性会被实例共享）
2.在创建子类实例时，不能向父类的构造函数传递参数
借用构造函数继承
借用构造函数继承的基本思想相当简单，即在子类构造函数的内部使用call()或apply()方法调用父类构造函数,这样子类的实例就都会具有属于自己的引用类型的属性，如下代码：
function Chinese(name) {
//使用call继承Person
Person.call(this,name);
}
var chinese = new Chinese('lianqi');
console.log(chinese.name); //"lianqi"
chinese.firends.push('Irving');
console.log(chinese.firends); // ["James", "Curry", "Irving"]
var chinese01 = new Chinese('Kobe');
console.log(chinese01.firends); // ["James", "Curry"]
借用构造函数继承的模式，解决了原型链继承中子类共享父类中引用类型属性的问题，而且创建子类实例时可以向父类的构造参数传递参数，还可以实现多继承（call多个父类对象）
借用构造函数继承的方式也存在问题：
1.方法都在构造函数中定义，因此函数复用就无从谈起了
2.子类实例只能继承父类的实例（私有）属性和方法，在父类原型中定义的方法，对子类是不可见的，因此不能继承父类的原型（公有）属性和方法
拷贝继承
拷贝继承的私有属性通过call来继承，公有属性通过函数extend()来继承，拷贝继承实现了子类实例对父类的私有属性和公有属性的继承。
function extend(newObj,oldObj){
for (var attr in oldObj){
newObj[attr] = oldObj[attr]
}
}
function Chinese(){
//子类继承父类的私有属性和方法
Person.call(this)
}
//子类继承父类的公有属性和方法
extend(Chinese.prototype,Person.prototype);
var chinese = new Chinese('liaqi');
chinese.firends.push('Irving');
console.log(chinese.firends); // ["James", "Curry", "Irving"]
chinese.skill(); //"running"
拷贝继承也有它存在的问题：
1.效率较低，内存占用高（因为要拷贝父类的属性）
2.无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）
组合继承
组合继承的原理是通过原型链实现对公有属性和方法的继承，通过借用构造函数来实现对私有属性和方法的继承。
function Chinese(name) {
//继承私有属性和方法
Person.call(this,name); //第二次调用父类Person()
}
//继承公有属性和方法
Chinese.prototype = new Person(); //第一次调用父类Person()
//手动设置子类的constructor
Chinese.prototype.constructor = Chinese;
Chinese.prototype.speakChinese = function (){
console.log('speak chinese')
};
var chinese = new Chinese();
chinese.firends.push('Irving');
chinese.speak(); //"speak"
chinese.speakChinese(); //"speak chinese"
console.log(chinese.firends); //["James", "Curry", "Irving"]
var chinese01 = new Chinese();
chinese.speak(); //"speak"
console.log(chinese01.firends); //["James", "Curry"]
组合继承可以向父类构造函数传参，避免了子类实例共享父类的引用类型的属性，每个子类实例还可以使用相同的方法。组合继承避免了原型链和借用构造函数的缺点，融合了他们的优点
组合继承的缺点是调用了两次父类构造函数
寄生式继承
寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，然后返回这个对象。
function createPerson(original) {
//创建一个新对象
var obj = Object.create(original);
//给对象添加方法
obj.speakChinese = function (){
console.log('speak chinese')
}
//返回对象
return obj
}
var person = {
name: 'lianqi',
friends: ['James','Curry']
}
var chinese = createPerson(person);
chinese.speakChinese(); //"speak chinese"
createPerson()函数将接受的参数作为新对象的基础返回新对象，新对象不仅拥有了person的属性和方法，还有了自己的方法speakChinese()。在主要考虑对象而不是自定义类型活构造函数的情况下，寄生式继承是一种有用的模式。
寄生组合式继承
寄生组合式继承不会初始化两次调用父类构造函数，避免了组合继承的缺点，通过把父类原型寄生在一个新类的原型上，再赋值给子类原型。这样做的高效体现在只调用了一次父类构造函数，并且因此避免了在子类原型上创建不必要的、多余的属性
//创建子类
function Chinese(){
Person.call(this)
}
//创建一个新类，新类没有任何属性和方法
function Temp() {
}
//父类的原型属性和方法寄生在新类的原型
Temp.prototype = Person.prototype;
//再把新类的原型属性和方法赋值给子类的原型，新类就相当于一个临时中转站，这样就避免了调用创建子类实例调用两次父类构造函数
Chinese.prototype = Temp.prototype;
//为子类原型添加constructors属性，从而弥补因重写原型而失去的默认constructor属性
Chinese.prototype.constructor = Chinese;
var chinese = new Chinese();
chinese.speak(); //"speak"