JS中继承

<script>
    //js 中继承可以按照是否使用object函数。分为两类；
    //原型链继承和原型式继承有一样的优缺点。构造函数继承和寄生式继承也相互对应


    //1111111111:原型式继承（原型链式继承），核心：将父类的实例作为子类的原型

    subType.prototype=new superType();
    subType.prototype.constructor=subType
    //所有原型链式继承的继承方是都要修改子类构造函数的指向。否则子类(实例)的构造函数会指向父类subType
    //优点：父类方法可以复用；
    //缺点：（1）：父类的引用属性会被所有子类实例共享，（2）：子类构建实例是不能向父类传递参数，




    //222222222:构造函数继承
    //核心：将父类构造函数的内容复制给了子类的构造函数。（这是所有继承中唯一一个不涉及到prototype的继承）。
    superType.call(subType);
    //优点：和原型链继承完全反过来 （1）：父类的引用属性不会被共享。 （2）：子类构建实例时可以向父类传递参数；
    //缺点：父类的方法不能复用，子类实例的方法每次都是单独创建的。




    //333333333333:组合继承；
    //核心：原型式继承和构造函数继承的组合，兼具二者的优点；
     function superType(){
         this.name="asdafasd";
         this.arr=[123,123,1243]
     }
     superType.prototype.say=function(){
         alert(1)
    }
    function subType() {
        superType.call(this)//第二次调用superType,
    }
    subType.prototype=new superType()//第一次调用superType;
    //优点：（1）：父类的方法可以被复用；（2）父类的引用属性不会被共享；（3）:子类构建实例时可以向父类传递参数。
    //缺点：调用了两次父类的构造函数。造成性能上的浪费；



    //444444444444444;原生式继承；
    //核心：其继承的object方法本质上是对参数对象的一个浅复制
    //优点：父类方法可以复用。
    //缺点：（1）父类的引用属性会被所有子类实例共享；（2）：子类构建实例时不能向父类传递参数
    function object(o) {
        function F() {
        }
        F.prototype=o;
        return new F();
    }
    var person={
         name:"nicaksd",
         friends:["lin","vn","daxue"]
    }
    var anotherPerson=object(person);
     anotherPerson.name="asdf";
     anotherPerson.friends.push("buqu");

    var ganotherPerson=object(person);
    ganotherPerson.name="avas";
    ganotherPerson.friends.push("mnazi");
    alert(person.friends)//"lin","vn","daxue","buqu","mnazi"
     //es5 新增了object。create()来规范化原生式继承，可以接受两个参数：一个是用作新对象原型的对象。和（可选）为新对象定义而外的属性的对象




    //55555555555555555;寄生式继承
    //核心：使用原生式继承获得一个目标对象的浅复制。然后增强这个浅复制的能力；
    //优缺点：仅提供一种思路：没什么优点；
    function createAnother(original) {
        var clone=createAnother(original)//通过创建一个新的对象；
        clone.sayHi=function () {
            alert("hi")//以函数来增强这个对象的属性；
        };
        return clone;
    }
    var person={
        name:"nicaksd",
        friends:["lin","vn","daxue"]
    }
    var anotherPerson=createAnother(person);
    anotherPerson.sayHi();//"hi'


    //66666666666666666:寄生组合继承；
    //完美的继承，可以解决组合继承两次调用父类的构造函数造成浪费的缺点；
    function inheritPrototype(subType,superType) {
        var prototypel=object(superType.prototype);//创建了父类原型的浅复制；
        prototype.constructor=subType;//修正原型的构造函数；
        subType.prototype=prototype;//将子类的原型替换成这个原型（父类）
    }
    function SuperType(name) {
        this.name=name;
        this.colors=["red","blue","green"];
    }
    SuperType.prototype.sayName=function () {
        alert(this.name);
    };
    function SubType(name,age) {
        SuperType.call(this,name);
        this.age=age;
    }
   //核心：因为是对父元素原型的复制，所以不包含父类的构造函数，也就不会调用两场父类的构造函数造成浪费
    inheritPrototype(SubType,SuperType);
    SubType.prototype.sayAge=function () {
        alert(this.age)
    }

</script>