js继承

//父类
     function Person(name){
          this.name=name;     //属性
          this.sum = function(){      //方法
              alert (this.name)
          }
      }
      var person=new Person('llp');
      Person.prototype.age=10;    //给构造函数添加了原型属性

1、原型链继承
关键：将新的构造函数的原型等于父类的实例。
优点：可继承父类构造函数属性，父类原型属性，实例构造函数属性。
缺点：新实例无法向父类构造函数传参，引用类型的属性被所有实例共享。

 //1、原型链继承
     function Per(){
         this.name = 'hhl';
     }
     Per.prototype=new Person(); //关键，将实例对象和父类原型对象链接在一起。
     var per1=new Per();
     per1.age=23;
     var per2=new Per();

2、借用构造函数继承
关键：用call和apply将父类构造函数引入子类构造函数，通过改变this的指向继承。
优点：只继承了父类构造函数的属性，没有继承父类原型的属性，可以继承多个父类构造函数，子类可向父类传参。
缺点：方法都在构造函数中定义，每次创建实例都会创建一遍方法。创建的实例只是子类的实例不是父类的。

     //子类
	function Con(){
      Person.call(this,'jin');
       this.age=12;
	 }
     var con1 = new Con();
     console.log(con1.name); //jin
     console.log(con1.age);  //12
     console.log(con1 instanceof Person);

3、组合继承（原型链继承和借用构造函数继承）
关键：使用原型链继承实现原型方法的继承，借用构造函数继承实现原型属性的继承。
优点：可以继承父类原型的属性，可传参，可复用。每个实例引入的构造函数属性是私有的。
缺点：调用了2次父类构造函数，耗内存。

//3、组合继承（原型链继承+借用构造函数继承）
    function Sub(name){
         Person.call(this,name);
     }
     Sub.prototype=new Person();
     var sub=new Sub('sub');
     console.log(sub.name);  //sub
     console.log(sub.age);   //10

4、原型模式继承
关键：通过new或者Object.create克隆出一个一模一样的对象。
优点：相当于复制克隆一个对象。
缺点：所有的实例都会继承原型上的属性。新的属性如是后面添加的，无法实现复用。

//4、原型式继承
   function cont(obj){
        function F(){};
        F.prototype=obj;
        return new F();
    }
    var sup=new Person();
    var sup_son=cont(sup);
    console.log(sup_son.age)    //10

5、寄生式继承
关键：就是给原型模式继承再套个壳，创建一个仅用于封装继承过程的函数，最后返回对象。
缺点：没有用到原型，无法复用。每次创建对象都会创建一遍方法。

//5、寄生方式
        function content(obj){
            function F(){};
            F.prototype=obj
            return new F();
        }
        var sub1=new Person();
        function subObject(obj){
            var sub=content(obj);
            sub.name='ggg';
            return sub;
        }
        var sub2=subObject(sub1);
        console.log(sup2.name);

6、寄生组合继承
关键：寄生：在函数内返回对象；组合：函数原型等于另一个实例，在函数中用call和apply引入另一个构造函数，可传参。
优点：只调用了一次父类构造函数，并避免在父类原型上创建不必要的多余属性。

//6、寄生组合式继承
    //寄生
     function content(obj){
         function F(){};
         F.prototype=obj
         return new F();
     }
     var con=content(Person.prototype);
     //组合
     function Sun(){
         Person.call(this)
     }
     Sun.prototype=con;
     con.constructor=Sun;
     var sun1=new Sun();
     console.log(sun1.age)   //10

以上就是js实现继承的过程~~
接下来来探讨如何将一个类的原型和另一个类的原型相关联,达到实现继承公共方法的方式：
例如Children 类和Parent类

1. 使用 __ proto __ 和原型的关系
   Children.prototype.__ proto __=Parent.prototype
2. 使用setPrototypeof来设置原型
   Object.setPrototypeof(Children.prototype,Parent.prototype)
3. 使用Object.create()来实现拷贝
   Children.prototype=Object.create(Parent.prototype)