JS中的继承方式总结

1. 原型链继承(又称类继承)

Child.prototype = new Parent();

 function Parent (name, age) {
     this.name = name;
     this.age = age;
 }
 Parent.prototype.say = function(){
     console.log('hello, my name is ' + this.name);
 };
 function Child() {
 }
 Child.prototype = new Parent('pursue');
 var child1 = new Child();
 child1.say(); //hello, my name is pursue
 var child2 = new Child();
 console.log(child1.say === child2.say);//true
 console.log(child1.name === child2.name);//true

通过子类的原型prototype对父类实例化实现。利用将父类实例赋值给子类原型，达到继承的目的：子类原型可访问父类原型上的属性和方法 以及 父类构造函数中复制的属性和方法(类的构造函数中的属性和方法会在实例化对象的时候复制的该实例化对象中去)

Child.prototype instanceof Parent  //true

缺点一：父类的共有属性是引用类型时，子类的一个实例更改子类原型从父类构造函数继承来的该属性时，会直接引起子类其他实例中该继承属性值的变化。

缺点二：子类通过原型prototype实现对父类的实例化而实现继承，因此不能在创建父类的时候给父类传参，所以在实例化父类的是无法对父类构造函数内的属性进行初始化。

2. call(thisObj, param1, param2,...)　　// 构造函数继承

 function Parent(username){
     this.username = username;
     this.hello = function(){
       alert(this.username);
     }
   }
　　Parent.prototype.show = function() {console.log("show me")}
   function Child(username,password){
     Parent.call(this,username);
     this.password = password;
     this.world = function(){
       alert(this.password);
     }
   }
   var parent = new Parent("zhangsan");
   var child = new Child("lisi","123456");
   parent.hello();
   child.hello();
   child.world();
　　　child.show(); //TypeError

3. apply(thisObj, [param1,param2,...])　　// 构造函数继承

 function Parent(username){
     this.username = username;
     this.hello = function(){
       alert(this.username);
     }
   }
　　Parent.prototype.show = function() {console.log("show me")}
   function Child(username,password){
     Parent.apply(this,new Array(username));
     this.password = password;
     this.world = function(){
       alert(this.password);
     }
   }
   var parent = new Parent("zhangsan");
   var child = new Child("lisi","123456");
   parent.hello();
   child.hello();
   child.world();
　　  child.show(); //TypeError

2，3 为构造函数式继承方式，通过在子类的构造函数作用环境中执行一次父类的构造函数实现，优化了 1 中的两个缺点，但是由于是通过构造函数继承的，故父类原型中的方法子类是无法调用到的，所以有了下面的组合继承方式。

4. 组合继承(call+原型链 / apply+原型链)

 function Parent(hello){
     this.hello = hello;
   }
   Parent.prototype.sayHello = function(){
     alert(this.hello);
   }
   function Child(hello,world){
     Parent.call(this,hello);//利用 call 方法 将父类的属性继承过来
     //Parent.apply(this,new Array(hello));//利用 apply 方法 将父类的属性继承过来
     this.world = world;//新增一些属性
   }
   Child.prototype = new Parent();//将父类原型中的的方法继承过来
   Child.prototype.sayWorld = function(){//新增一些方法
     alert(this.world);
   }
   var c = new Child("zhangsan","lisi");
   c.sayHello();
   c.sayWorld();

① 在子类构造函数中执行父类构造函数，② 在子类原型上实例化父类

5.寄生组合继承，与4相似，只是将原型链换做了Object.create(Parent.prototype)

 function Parent(hello){
     this.hello = hello;
   }
   Parent.prototype.sayHello = function(){
     alert(this.hello);
   }
   function Child(hello,world){
     Parent.call(this,hello);//利用 call 方法 将父类的属性继承过来
     //Parent.apply(this,new Array(hello));//利用 apply 方法 将父类的属性继承过来
     this.world = world;//新增一些属性
   }
   Child.prototype = Object.create(Parent.prototype);//将父类的方法继承过来
   Child.prototype.sayWorld = function(){//新增一些方法
     alert(this.world);
   }
   var c = new Child("zhangsan","lisi");
   c.sayHello();
   c.sayWorld();

6.扩展Object类

Object.prototype.方法名 = function (parentObject) {

　　for(var attr in parentObject) {

　　　　this[attr] = parentObject[attr];

　　}

}

 function Parent (name) {
             this.name = name
             this.syaHi = function() {
                 console.log('name is '+this.name);
             }
         }

         function Child(pwd) {
             this.pwd = pwd;
             this.info = function() {
                 console.log(this.name, this.pwd);
             }
         }

         Object.prototype.show = function(parentObject) {
             for (var attr in parentObject) {
                 this[attr] = parentObject[attr];
             }
         }
         var p = new Parent('zhangsan')；

         var c = new Child(12345);
         c.show(p);

         c.syaHi();    // zhangsan
         c.info();    // zhangsan,12345

7. 对象冒充　　在B(子类)的构造函数中，定义属性 bb = A(父类)的构造函数，在B的构造函数的最后再将bb删除

 function Parent (name) {
             this.name = name
             this.show = function() {
                 console.log('name is '+this.name);
             }
         }

         function Child(name) {
             this.method = Parent;    // 将Parent类的构造函数赋值给Child的一个方法
             this.method(name);        // 这里相当于把Parent的构造函数当作普通函数调用了一次，对象冒充
             delete this.method;        // 一处这个用来做对象冒充功能的method
         }

         var p = new Parent('父类')；
         p.show();    // name is 父类

         var c = new Child('子类');
         c.show();    // name is 子类