1、类式继承
第1步、声明父类
function SuperClass() {
this.superValue = true;
}
第2步、为父类添加共有方法
SuperClass.prototype.getSuperValue = function() {
return this.superValue;
}
第3步、声明子类
function SubClass() {
this.subValue = false;
}
第4步、继承父类，核心就是这一步，子类的原型指向第一个类的实例。
实例化父类的时候，实例对象复制父类构造函数内的属性和方法，并且将__proto__指向了父类的原型对象，这样就拥有了父类原型对象上的属性和方法。
将实例对象赋值给子类的原型，子类就可以访问父类的属性和方法。
SubClass.prototype = new SuperClass();
第5步、为子类添加共有方法
SubClass.prototype.getSubValue = function() {
return this.subValue;
}
使用子类：
var instance = new SubClass();
console.log(instance.getSuperValue()); // true
console.log(instance.getSubValue()); // false
判断类与实例的关系：
console.log(instance instanceof SuperClass); // true
console.log(instance instanceof SubClass); // true
console.log(SubClass instanceof SuperClass); // false 继承关系，而不是类与实例的关系
console.log(SubClass.prototype instanceof SuperClass); // true
console.log(instance instanceof Object); // true 说明所有对象也是Object的实例
缺陷一：子类的2个实例之间会互相影响
先科普一下，值类型有：字符串、数值、布尔值、null、undefined，特征是不可变。引用类型有：对象、数组、函数，特征是可操作，可改变。
当父类的共有属性是引用类型，然后一个子类实例修改了父类的属性值，那么任何指向引用类型的变量都会变，所以另一个子类实例的属性也就变了。例如：
function SuperClass() {
this.superValue = [true];
}
function SubClass() {}
SubClass.prototype = new SuperClass();
var instance1 = new SubClass();
var instance2 = new SubClass();
console.log(instance1.superValue); // [true]
instance1.superValue.push(8);
console.log(instance1.superValue); // [true, 8]
console.log(instance2.superValue); // [true, 8]
缺陷二：子类实例无法向父类传递参数
子类实例只能向子类传递参数，没有办法向父类传递参数。不举例了。
2、构造函数继承
构造函数继承，用的是传说中的.call或.apply方法。
// 第一步、声明父类
function SuperClass(id) {
// 引用类型共有属性，这次再看看是否解决的上面的缺陷一
this.books = ['JS', 'HTML5', 'CSS'];
// 值类型共有属性
this.id = id;
}
// 第二步、父类型声明原型方法
SuperClass.prototype.showBooks = function() {
console.log(this.books);
};
// 第三步、声明子类
function SubClass(id) {
SuperClass.call(this, id); // 精华所在
}
// 第四步，创建两个子类实例
var instance1 = new SubClass(1);
var instance2 = new SubClass(2);
// 使用和测试
instance1.books.push('PHP');
console.log(instance1.books); // ["JS", "HTML5", "CSS", "PHP"]
console.log(instance1.id); //1
console.log(instance2.books); // ["JS", "HTML5", "CSS"]
console.log(instance2.id); // 2
instance1.showBooks(); // TypeError
注意上面代码中的“精华所在”，也就是call的用法。
可以看到子类内部就一行代码，就是SuperClass.call(this, id);，当子类实例创建的时候，SuperClass.call(this, id)就被执行了一遍。那么发生了什么呢？
第一步，将SuperClass函数的this绑定到this指向的对象上，也就是子类实例
第二步，给SuperClass函数传参，传递的参数先是SuperClass函数自带的参数，然后依次是arg1, arg2, arg3...，这里是id，也就是子类的参数id传给了父类，父类呢，又赋值给了this指向的对象（也就是子类实例）的id方法
第三步，执行SuperClass函数。这样一来，父类就传递给子类实例方法和属性。
缺陷：看到上面的TypeError吧，父类的原型方法，子类根本继承不到，非要继承则必须放到父类构造函数里，但构造函数的方法写到构造函数的里面不是最佳实践，因为各个子类实例不能共用方法，浪费内存，所以，请看下面的组合继承：
3、组合继承
类式继承，是通过实例化一个父类，然后赋值给子类的prototype来实现。
构造函数式继承，是通过在子类的构造函数作用环境里，执行了一次父类的构造函数来实现的。
综合上述两点，就构成了组合继承。
// 第一步、声明父类，跟构造函数式继承一样
function SuperClass(name) {
// 引用类型共有属性，这次再看看是否解决的上面的缺陷一
this.books = ['JS', 'HTML5', 'CSS'];
// 值类型共有属性
this.name = name;
}
// 第二步、父类声明共有方法，也跟构造函数式继承一样
SuperClass.prototype.getName = function() {
console.log(this.name);
};
// 第三步、声明子类
function SubClass(name, time) {
SuperClass.call(this, name); // 这依然跟构造函数式继承一样
this.time = time; // 这跟类式继承一样
}
// 第四步，子类原型继承父类，跟类式继承一样
SubClass.prototype = new SuperClass();
// 第五步，子类原型方法，跟类式继承一样
SubClass.prototype.getTime = function() {
console.log(this.time);
}
// 使用和测试
var instance1 = new SubClass(1, 2015);
var instance2 = new SubClass(2, 2016);
instance1.books.push('PHP');
console.log(instance1.books); // ["JS", "HTML5", "CSS", "PHP"]
console.log(instance1.name); //1
console.log(instance1.time); //2015
console.log(instance2.books); // ["JS", "HTML5", "CSS"]
console.log(instance2.time); // 2016
缺陷：父类被调用了两次，浪费内存。但是这是目前用得最多的继承实现。