Javascript学习笔记：6种实现继承的方式

①原型链式继承

function Person(name){
    this.name=name;
}

Person.prototype.getName=function(){
    return this.name;
}

function Male(age){
    this.age=age;
}

Male.prototype=new Person("John");

Male.prototype.getAge=function(){
    return this.age;
}

var maleA=new Male(12);
console.log(maleA.getAge());//12
console.log(maleA.getName());//John

var maleB=new Male(25);
console.log(maleB.getAge());//25
console.log(maleB.getName());//John

原型链式继承的实质是重写构造函数的原型对象，代之以一个所要继承的类型的实例。该例子中Male类型继承了Person类型。这种继承方式，所有的子类型共享父类型的属性和方法，因为原型指向的是同一个父类型实例。所以，当任一个子类型实例改变了继承来的原型属性的值，那么其他实例的原型属性的值也将被改变。为了解决这个问题，出现了借用构造函数式继承。

②借用构造函数式继承

function Person(name){
    this.name=name;
}

Person.prototype.getName=function(){
    return this.name;
}

function Male(name,age){
    Person.call(this,name);
    this.age=age;
}

Male.prototype.getAge=function(){
    return this.age;
}

var maleA=new Male("A",12);
console.log(maleA.getAge());//12
console.log(maleA.name);//A
console.log(typeof maleA.getName);//undefined

var maleB=new Male("B",25);
console.log(maleB.getAge());//25
console.log(maleB.name);//B
console.log(typeof maleB.getName);//undefined

借用构造函数式继承的实质是在构造函数内调用父类型的构造函数，那么子类型将继承父类型构造函数内所添加的属性和方法。借用构造函数式继承的优点是可以在继承父类型的时候向父类型的构造函数传递参数，缺点是不能继承定义在父类型原型上的方法和属性。为了解决借用构造函数式继承的这个缺点，出现了组合式继承。

③组合式继承

function Person(name){
    this.name=name;
}

Person.prototype.getName=function(){
    return this.name;
}

function Male(name,age){
    Person.call(this,name);
    this.age=age;
}

Male.prototype=new Person();

Male.prototype.getAge=function(){
    return this.age;
}

var maleA=new Male("A",12);
console.log(maleA.getAge());//12
console.log(maleA.name);//A
console.log(maleA.getName());//A

var maleB=new Male("B",25);
console.log(maleB.getAge());//25
console.log(maleB.name);//B
console.log(maleB.getName());//B

 组合式继承是将原型链式继承和构造函数式继承组合在一起使用，从而发挥两者的长处。其背后的思路是使用原型链来实现对原型属性和方法的继承，而通过借用构造函数实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数复用，又能保证每个实例都有它自己的属性。

④原型式继承

function object(o){
    function F(){}
    F.prototype=o;
    return new F();
}

var person={};
person.name='John';
person.getName=function(){
    return this.name;
}

var male=object(person);
male.age=22;
male.getAge=function(){
    return this.age;
}

console.log(male.name);//John
console.log(male.getName())//John
console.log(male.age);//22
console.log(male.getAge())//22

 原型式继承是基于现有对象然后借助原型创建新的对象，新对象拥有现有对象的所有属性和方法，同时还不用创建自定义类型，其实质上是对现有对象的浅复制，新对象与现有对象共享现有对象的属性和方法。ECMASctipt5通过新增Object.create()方法规范了原型式继承。这个方法接受两个参数，一个用作新对象原型的对象和（可选的）一个为新对象定义额外属性的对象。上面的例子可以改写为：

var person={};
person.name='John';
person.getName=function(){
    return this.name;
}

var male=Object.create(person,{
    age:{
        value:22
    }
});

male.getAge=function(){
    return this.age;
}
console.log(male.name);//John
console.log(male.getName())//John
console.log(male.age);//22
console.log(male.getAge());//22

⑤寄生式继承

function Male(original,age){
    var clone=Object.create(original);
    clone.age=age;
    clone.getAge=function(){
        return this.age;
    }
    
    return clone;
}

var person={};
person.name="John";
person.getName=function(){
    return this.name;
}

var male=Male(person,22);

console.log(male.name);//John
console.log(male.getName())//John
console.log(male.age);//22
console.log(male.getAge());//22

寄生式继承与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真是它做了所有工作一样的返回对象。这种继承方式新对象与现有对象共享现有对象的所有属性和方法。改变先有对象的属性的值，新对象对应属性的值也将改变。原型式继承和寄生式继承，都不能实现函数的复用。为了解决这一问题，出现了寄生组合式继承。

⑥寄生组合式继承

function inheritPrototype(subType,superType){
    var prototype=Object.create(superType.prototype);
    prototype.constructor=subType;
    subType.prototype=prototype;
}

function Person(name){
    this.name=name;
}

Person.prototype.getName=function(){
    return this.name;
}

function Male(name,age){
    Person.call(this,name);
    this.age=age;
}

inheritPrototype(Male,Person);

Male.prototype.getAge=function(){
    return this.age;
}

var maleA=new Male("A",22)

console.log(maleA.name);//A
console.log(maleA.getName())//A
console.log(maleA.age);//22
console.log(maleA.getAge());//22

寄生组合式继承，即通过借用构造函数来继承属性，通过原型链的混成形式来继承方法，其背后的基本思路是：不必为了指定子类型的原型而调用父类型的构造函数，我们所需要的无非就是父类型的原型的一个副本而已。本质上，就是使用寄生式继承来继承父类型的原型，然后再将结果指定给子类型的原型。