javascript-面向对象之继承(1).

ECMAScript只支持继承，不支持接口实现，而实现继承的方式依靠原型链完成
原型+对象构造之间的关系结构，形成的像链条一样的，称之为原型链

//继承，通过原型链实现
    function Box()                    //被继承的函数叫做超类型(父类 ， 基类)
    {
        this.name ='Lee';
    }
    
    function Desk()                    //继承的函数叫做子类型(子类，派生类)
    {
        this.age =100;                
    }
    
    function Table()
    {
        this.level='AAAAA';
    }
    
    //通过原型链继承,超类型实例化后的对象实例，赋值给子类型的原型属性
    //new Box()会将Box构造里的信息和原型里的信息都交给Desk
    //Desk的原型，得到的是Box的构造+原型里的信息
    Desk.prototype =new Box();    
    Table.prototype =new Desk();
    
    var desk =new Desk();
    alert(desk.name);               //Lee
    
    var table =new Table();
    alert(table.name);                //Lee    

★原型链+借用构造函数的模式，这种模式称为组合模式

//为了解决引用共享和超类型无法传参的问题，我们采用一种叫借用构造函数的技术，或者成为对象冒充(伪造对象、经典继承)的技术来解决这两种问题

function Box(name ,age)
        {
            this.name =name;
            this.age = age;
            this.family=['哥哥' , '姐姐' , '妹妹']; //引用类型,放在构造里面就不会被共享
        }
        
        Box.prototype.run =function()
        {
            return this.name + this.age +'运行中';
        }
        
        //构造函数里的方法，放在构造函数里，每次实例化，都会分配一个内存地址，浪费，所以最好放在原型上
        
        function Desk(name ,age)
        {
            Box.call(this,name ,age)      //对象冒充 ★只能继承构造里面的信息
        }
        
        Desk.prototype =new Box();         //圆形链继承

        var desk =new Desk('Lee' , 100);
        alert(desk.run());

★原型式继承 单独使用并不方便，要和一下几种模式配合

//临时中转函数
        function obj(o)            //o表示将要传递进入的一个对象
        {
            function F(){};     //F构造是一个临时新建的对象,用来存储传递过来的对象
            F.prototype =o;        //将o对象实例赋值给F构造的原型对象
            return new F();        //最后返回这个得到传递过来对象的对象实例
        }
    
        //F.prototype=o 其实就相当于 Desk.prototype = new Box();
    
        //这是字面量的声明方式,相当于var box =new Box();
        var box ={
            name:'Lee',
            age:100,
            family:['哥哥' , '姐姐' , '妹妹']
        };
    
        //box1就等于new F();
        var box1 =obj(box);
        alert(box1.name);               
        alert(box1.family);                    //'哥哥' , '姐姐' , '妹妹'
        box1.family.push('弟弟');       
        alert(box1.family);                    //'哥哥' , '姐姐' , '妹妹' ,'弟弟'
        
        var box2=obj(box);
        alert(box1.family);              //'哥哥' , '姐姐' , '妹妹' ,'弟弟' [引用类型的属性共享了]

 ★寄生式继承=原型式+工厂模式

//临时中转函数
        function obj(o)            
        {
            function F(){};     
            F.prototype =o;        
            return new F();        
        }
    
        //寄生函数
        function create(o)
        {
            var f =obj(o);            //这里用obj(o);
            f.run =function ()        //这里可以对f进行扩展
            {
                return this.name+'方法';
            }
            return f;
        }
        var box ={
            name:'Lee',
            age:100,
            family:['哥哥' , '姐姐' , '妹妹']
        };
    
        var box1 =create(box);
        alert(box1.run());

★★寄生组合继承[为了解决 组合式继承的 超类型会被两次调用的问题]

        //临时中转函数
        function obj(o)            
        {
            function F(){};     
            F.prototype =o;        
            return new F();        
        }
    
        //寄生函数
        function create(box , desk)
        {
            var f =obj(box.prototype); 
            f.constructor=desk;                //调整原型构造指针
            desk.prototype=f;
        }
        
        function Box(name , age)
        {
            this.name =name;
            this.age=age;
        }
    
        Box.prototype.run =function()
        {
            return this.name + this.age +'运行中...'
        }
        
        function Desk(name ,age)
        {
            Box.call(this, name ,age); 
        }

        //通过寄生组合继承来实现继承
        create(Box , Desk);
        var desk =new Desk('Csn' ,100);
        alert(desk.run());
        
        alert(desk.constructor);