11、继承的实现方式及比较

1、简单原型链继承

function Super(){
	this.val = 1;
	this.arr = [1];
}
function Sub(){
	// ...
}
Sub.prototype = new Super();    // 核心
var sub1 = new Sub();
var sub2 = new Sub();
sub1.val = 2;
sub1.arr.push(2);
alert(sub1.val);    // 2
alert(sub2.val);    // 1
alert(sub1.arr);    // 1, 2
alert(sub2.arr);    // 1, 2

优点：简单，易于实现
缺点：1.修改sub1.arr后sub2.arr也变了，因为来自原型对象的引用属性是所有实例共享的。
（原因：执行sub1.arr.push(2);先对sub1进行属性查找，找遍了实例属性（在本例中没有实例属性），没找到，就开始顺着原型链向上找，拿到了sub1的原型对象，一搜身，发现有arr属性。于是给arr末尾插入了2，所以sub2.arr也变了）
2.创建子类实例时，无法向父类构造函数传参

2、构造函数继承

function Super(val){
    this.val = val;
    this.arr = [1];

    this.fun = function(){
        // ...
    }
}
function Sub(val){
    Super.call(this, arguments);   // 核心
    // ...
}

var sub1 = new Sub(1);
var sub2 = new Sub(2);
sub1.arr.push(2);
alert(sub1.val);    // 1
alert(sub2.val);    // 2

alert(sub1.arr);    // 1, 2
alert(sub2.arr);    // 1

alert(sub1.fun === sub2.fun);   // false，因为sub1和sub2各自拥有fun,它们的内存地址是不同的

优点：

1.解决了子类实例共享父类引用属性的问题
2.创建子类实例时，可以向父类构造函数传参

缺点：

1.无法实现函数复用，每个子类实例都持有一个新的fun函数，如果实例太多，会造成内存大量被占用
2.父类prototype里的东西不能获取到

3、

  function Parent (value) {
        this.value = value
        this.arr = ['one']
    }
    Parent.prototype.fun = function () {
        return 'smile'
    }

    function Sub(value){
        Parent.call(this,value)
    }

    Sub.prototype = new Parent()

    var sub1 = new Sub(1)
    var sub2 = new Sub(2)

    console.log(sub1.value) //1
    console.log(sub2.value) //2

    console.log(sub1.fun == sub2.fun) //true

说明：
1.把实例函数都放在原型对象上，以实现函数复用。同时还要保留借用构造函数方式的优点，通过Parent.call(this,value)继承父类的基本属性和引用属性并保留能传参的优点；通过Sub.prototype = new Parent()继承父类函数，实现函数复用；
2.优点：
不存在引用属性共享问题；
可传参；
函数可复用；
3.缺点
子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，而子类实例上的那一份屏蔽了子类原型上的。。。又造成了内存浪费：
例如：console.log(sub1）