javascript對象(3)

這個對象，不是那個對象，第三哦！

對象之間會存在繼承，所以，來說一下他們之間存在的三種三種繼承方式：

　　1、冒用繼承　　　　

 1 　　　　　　　　//創建了孫悟空構造函數
 2             function Sun(change,weapon,gf){
 3                 this.change = change;
 4                 this.weapon = weapon;
 5                 this.gf = gf;
 6                 this.bianshen = function(){
 7                     alert("吃俺老孫一棒");
 8                 }
 9             }
10             
11             //給原型上添加一個方法
12             /*Sun.prototype.bianshen = function(){
13                 alert("吃俺老孫一棒");
14             }*/
15             
16             //創建豬八戒構造函數
17             function Zhubajie(name){//name是豬八戒自己單獨有的屬性
18                 this.name = name;
19                 //創建一個屬性，屬性值是Sun構造函數
20                 this.sun = Sun;
21                 this.sun("仙桃","金箍棒","紫霞仙子");
22                 delete this.sun;//刪除掉這個屬性
23             }
24             
25             var zbj = new Zhubajie("豬八戒");
26             
27             
28             zbj.bianshen();//方法可以使用
29             alert(zbj.weapon);
30             
31             
32             //zbj 和Sun  不是同一類型的
33             alert(zbj instanceof Sun); //false 

　　　　這就是第一種繼承方式。

　　　　【註意】冒用繼承缺點：不能使用原型上的方法和屬性     優點：可以傳遞參數；

　　2、原型繼承

 1 　　　　　　　function Dan(car,money,home){
 2                 this.car = car;
 3                 this.money = money;
 4                 this.home = home;
 5             }
 6             
 7             //發方法聲明在原型對象上
 8             Dan.prototype.shoping = function (){
 9                 alert("買買買");
10             }
11             Dan.prototype.money = "5億";
12             
13             //這個實例化對象是Dan的兒子，可以使用Dan的屬性和方法
14             var son = new Dan("勞斯萊斯幻影","10億","四合院");
15             
16             
17             //創建一個乞丐構造函數
18             function S(name){
19                 this.name = name;
20             }
21             
22             //讓乞丐繼承富豪的屬性和方法
23             //把乞丐的構造函數原型修改成乾爹的原型，這樣，乞丐實例化對象就可以使用乾爹的屬性和方法。(兩種方法)
24 //            S.prototype = Dan.prototype;
25             S.prototype = new Dan();
26             
27             //把S的原型對象constructor指針指回自己，否則會出問題
28             S.prototype.constructor = S;           
29             var s = new S("蘇乞兒");
30             s.shoping();
31             alert(s.money);
32             
33             //判斷s的爸爸是不是  Dan
34             alert(s instanceof Dan);//true  s 和  Dan不是一個東西 

　　　　這種繼承方式就是將新建的父類對象賦給子類構造函數的原型。

　　　  【註意】原型鏈繼承缺點：不能傳遞參數      優點：可以使用原型 上的方法 ；　　　　

　　3、混合繼承　

 1 　　　　　　function Person(name,id,sex){
 2                 this.name = name;
 3                 this.id = id;
 4                 this.sex = sex;
 5                 this.think = function(ss){
 6                     alert(ss);
 7                 }
 8             }
 9             
10             Person.prototype.eat = function(){
11                 alert("呵呵");
12             }
13             
14             
15             
16             function XM(name,id,sex,clas){
17                 this.clas = clas;
18                 //call方法是用來繼承用的。你想繼承那個對性的屬性，就要把屬性傳遞進來；
19 //                Person.call(this,name,id,sex);
20                 
21                 //apply和call功能相同；
22                 //區別  call方法  參數要一個一個傳，  apply方法可以傳參數數組
23                 //優先選擇apply方法使用
24                 Person.apply(this,arguments);
25             }
26             
27             //原型鏈繼承  +  call/apply   叫混合繼承
28             XM.prototype = new Person();
29             XM.prototype.constructor = XM;
30             
31             
32             var xiaoming = new XM("小明","12312112112332","男","一年級二班");
33             alert(xiaoming.name);//列印小明名字屬性
34             xiaoming.think("坎坎坷坷");
35             
36             //現在有一個需要，讓小明可以使用Person對象原型上的方法
37             xiaoming.eat();

　　　　第三種方式就是 冒用繼承 + 原型繼承  ，既能繼承父類的原型，完成復用，又能向父類傳遞參數。

　　　　javascript所有的內容就到這裡了，希望可以幫到大家！！！！！！