学习笔记：javascript中的六种继承

今天学习了javascript中的继承，以下是总结的笔记，有不足或者欠妥的地方希望能和亲爱的你一起谈论：

第一种：原型链式继承方式

function Box(){
      this.name="lily";
    }
    function Desk(myage){
         this.age=myage;
    }
    Desk.prototype=new Box();    //用这种方式写函数，否则每次使用该方法都会开辟空间，浪费内存
    var desk=new Desk(20);
    alert(desk.name);                     //结果为：lily

    alert(desk.age);                        //j结果为：20

使用这种方式不能给父类的变量初始化值

第二种：对象冒充方式

    function Box(name,age){
      this.name=name;
      this.age=age;
      this.myprint=function(){
        return this.name+this.age ;
        }
    }
    function Desk(name,age){
       Box.call(this,name,age);
    }
    var desk=new Desk('lily',20);
    var p=desk.myprint();

    alert(p);                     //结果为：lily20

这种方式解决了不能给父类传递参数的问题

  
    第三种：组合方式
   function Box(myname)
    {
       this.name=myname;
           
    }
    Box.prototype.myprint=function(){
        return '名字：'+this.name ;
        }                 
      function Desk(myage)
    {
       this.age=myage;
       Box.call(this,'lily');  //对象冒充
    }
    Desk.prototype=new Box();    //原型链的方法
    var desk = new Desk(20);
    var a=desk.myprint(); 
    alert(a);                                      //输出结果为：名字：lily

    alert(desk.age);                     //输出结果为:20

这种方式是JavaScript中最常用的一种方法

    第四种：原型式继承
    function obj(o){
        function F(){}
        F.prototype=o;
        return new F();
        }
    var box={
        name:'lily'
        }
    var box1=obj(box);
    alert(box1.name);                     //输出结果为：lily
    //这种继承借助原型并基于已有的对象创建新对象，同时还不必此创建自定义类型

    第五种：寄生式继承
    function obj(o){
        function F(){}
        F.prototype=o;
        return new F();
        }
    //寄生函数
    function create(o)
    {
        var f=obj(o);
        f.fun=function(){
            return '请确认：'+this.name+this.age;
            }
        return f;
    }
    var p={
        name:'lily',
        age:20
        }
    var p1=create(p);
    alert(p1.fun());     //输出结果是：请确认：lily20
    alert(p1.name);      //lily
    第六种：寄生式组合继承
    function obj(o){
        function F(){}
        F.prototype=o;
        return new F();
        }
    //寄生函数
    function create(box,desk)
    {
        var f=obj(box);
        f.constructor=desk;    //调整原型构造指针，避免出错        
        desk.prototype=f;
    }
   function Box(myname,myage)
    {
       this.name=myname;
       this.age=myage;
           
    }
    function Desk()
    {
       Box.call(this,'lily',20);  //对象冒充
    }
    create(Box,Desk);
    var desk=new Desk();
    alert(desk.name);              //输出结果为：lily
    alert(desk.age);               //输出结果为：20