javascript对象(3)

这个对象，不是那个对象，第三哦！

对象之间会存在继承，所以，来说一下他们之间存在的三种三种继承方式：

　　1、冒用继承　　　　

　　　　　　　　//创建了孙悟空构造函数
            function Sun(change,weapon,gf){
                this.change = change;
                this.weapon = weapon;
                this.gf = gf;
                this.bianshen = function(){
                    alert("吃俺老孙一棒");
                }
            }
            
            //给原型上添加一个方法
            /*Sun.prototype.bianshen = function(){
                alert("吃俺老孙一棒");
            }*/
            
            //创建猪八戒构造函数
            function Zhubajie(name){//name是猪八戒自己单独有的属性
                this.name = name;
                //创建一个属性，属性值是Sun构造函数
                this.sun = Sun;
                this.sun("仙桃","金箍棒","紫霞仙子");
                delete this.sun;//删除掉这个属性
            }
            
            var zbj = new Zhubajie("猪八戒");
            
            
            zbj.bianshen();//方法可以使用
            alert(zbj.weapon);
            
            
            //zbj 和Sun  不是同一类型的
            alert(zbj instanceof Sun); //false 

　　　　这就是第一种继承方式。

　　　　【注意】冒用继承缺点：不能使用原型上的方法和属性     优点：可以传递参数；

　　2、原型继承

　　　　　　　function Dan(car,money,home){
                this.car = car;
                this.money = money;
                this.home = home;
            }
            
            //发方法声明在原型对象上
            Dan.prototype.shoping = function (){
                alert("买买买");
            }
            Dan.prototype.money = "5亿";
            
            //这个实例化对象是Dan的儿子，可以使用Dan的属性和方法
            var son = new Dan("劳斯莱斯幻影","10亿","四合院");
            
            
            //创建一个乞丐构造函数
            function S(name){
                this.name = name;
            }
            
            //让乞丐继承富豪的属性和方法
            //把乞丐的构造函数原型修改成干爹的原型，这样，乞丐实例化对象就可以使用干爹的属性和方法。(两种方法)
//            S.prototype = Dan.prototype;
            S.prototype = new Dan();
            
            //把S的原型对象constructor指针指回自己，否则会出问题
            S.prototype.constructor = S;           
            var s = new S("苏乞儿");
            s.shoping();
            alert(s.money);
            
            //判断s的爸爸是不是  Dan
            alert(s instanceof Dan);//true  s 和  Dan不是一个东西 

　　　　这种继承方式就是将新建的父类对象赋给子类构造函数的原型。

　　　  【注意】原型链继承缺点：不能传递参数      优点：可以使用原型 上的方法 ；　　　　

　　3、混合继承　

　　　　　　function Person(name,id,sex){
                this.name = name;
                this.id = id;
                this.sex = sex;
                this.think = function(ss){
                    alert(ss);
                }
            }
            
            Person.prototype.eat = function(){
                alert("呵呵");
            }
            
            
            
            function XM(name,id,sex,clas){
                this.clas = clas;
                //call方法是用来继承用的。你想继承那个对性的属性，就要把属性传递进来；
//                Person.call(this,name,id,sex);
                
                //apply和call功能相同；
                //区别  call方法  参数要一个一个传，  apply方法可以传参数数组
                //优先选择apply方法使用
                Person.apply(this,arguments);
            }
            
            //原型链继承  +  call/apply   叫混合继承
            XM.prototype = new Person();
            XM.prototype.constructor = XM;
            
            
            var xiaoming = new XM("小明","12312112112332","男","一年级二班");
            alert(xiaoming.name);//打印小明名字属性
            xiaoming.think("坎坎坷坷");
            
            //现在有一个需要，让小明可以使用Person对象原型上的方法
            xiaoming.eat();

　　　　第三种方式就是 冒用继承 + 原型继承  ，既能继承父类的原型，完成复用，又能向父类传递参数。

　　　　

　　　　

　　　　javascript所有的内容就到这里了，希望可以帮到大家！！！！！！