概念：

java引用變量有兩種類型:一種是編譯時類型，一種是運行時類型。編譯時類型由聲明該變量時使用的類型決定，運行時類型由實際給該變量的對象決定。如果編譯時類型和運行時類型不一致，就可能出現(xiàn)所謂的多態(tài)（Polymorphism）。

編譯期和運行期：

編譯期：javac編譯java代碼的時候，編譯成class字節(jié)碼文件，它會檢查語法錯誤。

father變量的類型由聲明該變量時使用的類型Father類型決定。

運行時：java執(zhí)行class字節(jié)碼文件，變量的類型由指向的實際對象決定，同時它會遇到運行時期的各種錯誤。

father變量雖然聲明的時候是Father類型，但是運行時，father變量指向的Child對象，那么它的類型就是Child類型。

但是子類不能指向父類，它會在編譯期就報錯：

class DuoTai{         //編譯時錯誤:檢查語法錯誤         //inti = new String();         //運行時錯誤：檢查運行時錯誤         staticString str ;         publicstatic void m(){                   Stringstr2 = str.substring(0,2);         }         publicstatic void main(String[] args){                   m();         }}
多態(tài)性：
//TODO 編寫普通創(chuàng)建案例和多態(tài)案例代碼。查看多態(tài)案例執(zhí)行重寫的方法是父類的還是子類的
class DuoTai{    /*        father變量指向子類對象。        在編譯時只檢查father是Father類型變量        在運行時，father代表的Child類型變量    */    publicstatic void main(String[] args){        //多態(tài)案例        Fatherfather = new Child();        father.method();        //普通案例        Father= new Father();        father.method();    }}class Father{    publicvoid method(){        System.out.PRintln("父類對象的方法");    }}class Child extends Father{    publicvoid method(){        System.out.println("子類對象的方法");    } }
 
在上面的案例中，我們創(chuàng)建了Child對象，但是使用它的父類Father類類型的變量來指向該Child對象。在子類對象中重寫了父類的同名方法。當(dāng)執(zhí)行該Child對象的method方法時，執(zhí)行的代碼是子類對象的代碼。
雖然看似定義時候，使用到的變量是Father類型，但是這僅僅是一個變量的引用，他真實指向內(nèi)存中的對象是該類型的子類對象Child類型的對象！所以使用該變量去調(diào)用重寫的method方法，實際上調(diào)用的還是Child對象的method方法。
在我們?nèi)粘Ｉ钪?，?jīng)常遇到這種情況，如：父親可以代表孩子辦理戶口、證件，或者可以代替辦理入學(xué)手續(xù)，但是實際上操作的對象還是孩子。這個時候，父親就可以代表孩子。
小明和大明是兄弟，他爹給大明辦完入學(xué)手續(xù)后又去給小明辦理入學(xué)手續(xù)，那么他爹在不同的時候，執(zhí)行相同的入學(xué)手續(xù)，但是實際操作的對象分別是小明和大明。
什么是多態(tài)：在不同的時刻，同一個變量，調(diào)用同一個方法，呈現(xiàn)的多種不同的行為特征，這就是多態(tài)。
//TODO代碼 他爹給大明小明辦理入學(xué)手續(xù)，不同時候打印不同語句
class RuXue{    publicstatic void main(String[] args){        Fatherfather ;        //給小明辦理入學(xué)手續(xù)        father= new XiaoMing();        father.ruxue();        //給大明辦理入學(xué)手續(xù)        father= new DaMing();        father.ruxue();    }}class Father{        Stringname = "父親";        publicvoid ruxue(){            System.out.println(name+ "辦理了入學(xué)手續(xù)！");        }}class XiaoMing extends Father{        Stringname = "小明";        publicvoid ruxue(){            System.out.println(name+ "辦理了入學(xué)手續(xù)！");        }}class DaMing extends Father{        Stringname = "大明";        publicvoid ruxue(){            System.out.println(name+ "辦理了入學(xué)手續(xù)！");        }}
這個時候，我們發(fā)現(xiàn)，父類類型的變量，指向了子類對象，這個時候父類可以代表子類，但是，當(dāng)父類類型的變量去執(zhí)行方法的時候，實際操作的對象的方法還是子類的！
一句話說，父類變量可以指向子類對象，并且代表子類對象！
//TODO創(chuàng)建多個子父類，然后驗證父類變量指向子類對象
class RuXue{    publicstatic void main(String[] args){        Fatherfather ;        //給小明辦理入學(xué)手續(xù)        father= new XiaoMing();        System.out.println(father.getClass().getName());         //給大明辦理入學(xué)手續(xù)        father= new DaMing();        System.out.println(father.getClass().getName());     }}
class Father{        Stringname = "父親";        publicvoid ruxue(){            System.out.println(name+ "辦理了入學(xué)手續(xù)！");        }}
class XiaoMing extends Father{        Stringname = "小明";        publicvoid ruxue(){            System.out.println(name+ "辦理了入學(xué)手續(xù)！");        }}
class DaMing extends Father{        Stringname = "大明";        publicvoid ruxue(){            System.out.println(name+ "辦理了入學(xué)手續(xù)！");        }}
//TODO體驗多態(tài)的實際用途，在不同時刻執(zhí)行不同功能
import java.util.Scanner;class Shopping{    publicstatic void main(String[] args){        System.out.println("請選擇您的支付方式：1、現(xiàn)金；2、支付寶；3微信");        Scannersc = new Scanner(System.in);        //從鍵盤獲取一個選擇的值int類型        intchoose = sc.nextInt();        Paypay = new Pay();        switch(choose)        {        case1:            pay= new Money();            break;        case2:            pay= new ZhiFuBao();            break;        case3:            pay= new WeiXin();            break;        }        pay.paying();    } }
import java.util.Scanner;class Shopping{    publicstatic void main(String[] args){        System.out.println("請選擇您的支付方式：1、現(xiàn)金；2、支付寶；3微信");        Scannersc = new Scanner(System.in);        //從鍵盤獲取一個選擇的值int類型        intchoose = sc.nextInt();        Paypay = new Pay();        switch(choose)        {        case1:            pay= new Money();            break;        case2:            pay= new ZhiFuBao();            break;        case3:            pay= new WeiXin();            break;        }        pay.paying();    } }//支付方法class Pay{    publicvoid paying(){    }}//現(xiàn)金支付class Money extends Pay{    publicvoid paying(){        System.out.println("現(xiàn)金支付");    }}//支付寶支付class ZhiFuBao extends Pay{        publicvoid paying(){        System.out.println("支付寶支付");        }}//微信支付class WeiXin extends Pay{        publicvoid paying(){        System.out.println("微信支付");        }}
我們知道，子類繼承父類后，除了具備父類的一些屬性后，還可以自己進行擴展自有的業(yè)務(wù)。這個時候子類可以訪問父類成員，但是父類成員絕對無法訪問子類自有成員，那么當(dāng)父類引用指向子類對象時候，只能調(diào)用在父類中定義過的方法，但無法調(diào)用子類額外拓展的方法！
該錯誤會在編譯期產(chǎn)生。父類引用調(diào)用子類的方法，在運行時期，執(zhí)行的是子類方法的代碼。
理解：父類引用只能調(diào)用在父類中定義過的方法
編譯期，檢查語法錯誤，同時還檢查多態(tài)性。并不檢查運行期對象的方法。也就是說，編譯期只管引用調(diào)用的編譯期類型的屬性或方法存在不存在，不管實際運行時，對象是否具備該方法。
 
class DuoTai{    publicstatic void main(String[] args){        //多態(tài)案例        Fatherfather = new Child();        //父類引用調(diào)用子類對象重寫的方法不報錯        father.method();        //父類引用調(diào)用子類自有的方法報錯        father.method2();    }}class Father{    publicvoid method(){        System.out.println("父類對象的方法");    }}class Child extends Father{    Stringname;    String id;    //重寫父類    publicvoid method(){        System.out.println("子類對象的方法");    }    //自有方法    publicvoid method2(){        System.out.println("子類對象的方法2");    }}
運行期，執(zhí)行運行時對象的方法業(yè)務(wù)。編譯通過后，在運行期，變量的類型是由對象的類型決定，那么運行時通過變量調(diào)用的方法是對象的方法。在多態(tài)情況下，雖然使用father類型變量調(diào)用子類的方法，但是實際上他指向的是子類，那么執(zhí)行的方法也就是子類的方法。
多態(tài)情況下的屬性調(diào)用：
父類中定義了和子類同名的屬性，當(dāng)使用父類引用時，去訪問同名屬性，那么訪問的是父類的屬性。
class DuoTai{    publicstatic void main(String[] args){        //多態(tài)案例        Fatherfather = new Child();        father.method();        //打印結(jié)果是：父類        System.out.println(father.name);       }}class Father{    Stringname = "父類";    String id;    publicvoid method(){        System.out.println("父類對象的方法");    }}class Child extends Father{    Stringname = "子類";    String id;    publicvoid method(){        System.out.println("子類對象的方法");    }    publicvoid method2(){        System.out.println("子類對象的方法2");    }}
注意：子父類中，方法一致叫重寫，屬性不叫重寫。
解析：
         Java中多態(tài)的靜態(tài)綁定和動態(tài)綁定。
         靜態(tài)綁定：變量屬于靜態(tài)綁定。
         即便子父類定義了同名屬性，當(dāng)使用父類引用去訪問該屬性，實際訪問的父類的屬性。
         動態(tài)綁定：方法屬于動態(tài)綁定。
         方法的動態(tài)綁定，當(dāng)執(zhí)行方法時候，就會執(zhí)行引用所指向的實際內(nèi)存中的對象方法（子類方法）
子類重寫父類要遵循“兩同兩小一大”
“兩同”即方法名相同，形參列表相同，實現(xiàn)重寫的必要條件。
“兩小”指的是子類方法返回值類型應(yīng)比父類方法返回值類型更小或相等，子類方法聲明拋出的異常類應(yīng)比父類方法聲明拋出的異常類更小或相等
如下案例：
Zi和Fu是繼承關(guān)系；Father和Child繼承關(guān)系，當(dāng)在father類中定義方法method（）要求返回Fu類類型對象，子類重寫 該方法后，可以返回Fu類類型對象或者子類型對象（在下面案例中，子類方法可以返回Fu或者Zi，因為Zi是繼承Fu的）
 
 
但是：如果父類定義的返回值要求是Zi，結(jié)果子類重寫該方法返回的是Fu，那就會報錯！因為Zi繼承Fu，F(xiàn)u可以代表Zi，但是Zi無法代表Fu，也就是說方法的返回值也具有多態(tài)特性，其實方法傳參的參數(shù)也可以具備多態(tài)特性！
class DuoTai{    public static void main(String[] args){        //多態(tài)案例        Father father = new Child();        father.method();        //System.out.println();    }}class Father{    String name = "父類";    String id;      Fu  method(){        System.out.println("父類對象的方法");        return null;    }}class Child extends Father{    String name = "子類";    String id;    public  Zi method(){        System.out.println("子類對象的方法");        Fu fu = new Fu();        Zi zi = new Zi();        return zi ;    }    public void method2(){        System.out.println("子類對象的方法2");    }} class Fu{}class Zi extends Fu{} 傳參也可以多態(tài)：class DuoTai{    public static void main(String[] args){        //打印結(jié)果：Fu        method(new Fu());        //打印結(jié)果：Zi，就說明了傳參也具備多態(tài)性        method(new Zi());    }    public static void method(Fu fu){        System.out.println(fu.getClass().getName());    }} class Fu{}class Zi extends Fu{} 
返回值的多態(tài)性：
“一大”指的是子類方法的訪問權(quán)限應(yīng)比父類方法的訪問權(quán)限更大或相等，如下案例中，我們子類重寫父類方法，子類的訪問權(quán)限是小于父類的，所以會報錯！反之則不會！
//子類重寫父類方法的權(quán)限比父類小，報錯class Father{    public void  method(){        System.out.println("父類對象的方法");    }}class Child extends Father{      void method(){        System.out.println("子類對象的方法");    }}//子類重寫父類方法的權(quán)限比父類大，正確class Father{    void method(){        System.out.println("父類對象的方法");    }}class Child extends Father{        publicvoid method(){        System.out.println("子類對象的方法");    }}   
 
 
那當(dāng)父類引用指向子類對象時候，不能調(diào)用父類沒有的方法，這個時候我們該怎么去調(diào)用子類對象的自有方法？
強制轉(zhuǎn)換與自動轉(zhuǎn)換：
 
   classDuoTai    {        public static void main(String[] args){            Father father  = new Father();            Childchild = new Child();            //自動轉(zhuǎn)換，向上轉(zhuǎn)換            father= child;            //編譯看左邊，發(fā)現(xiàn)father沒有method2方法，報錯            //father.method2();            //如果非要執(zhí)行child2中的方法，那么強制轉(zhuǎn)換            //強制轉(zhuǎn)換，向下轉(zhuǎn)換            Childchild2 = (Child)father;            //編譯看左邊，child類型對象有method2方法，Ok            child2.method2();        }  }    class Father    {        public   void method(){            System.out.println("父類對象的方法");        }    }    classChild extends Father    {         public  void method(){            System.out.println("子類對象的方法");        }        public   void method2(){            System.out.println("子類對象的方法2");        }    } 
注意：
當(dāng)把父類類型引用，強制轉(zhuǎn)換成子類類型引用，那么該引用指向的實際位置必須是子類對象。否則報錯！
   
 class DuoTai    {        public static void main(String[] args){            Father father  = new Father();            /*父類類型強制轉(zhuǎn)換成子類類型，編譯不報錯            但是，運行時            報錯：類型轉(zhuǎn)換錯誤ClassCastException*/            Child child = (Child)father;            child.method();        }    }    class Father    {        public   void method(){            System.out.println("父類對象的方法");        }    }    class Child extends Father    {         public  void method(){            System.out.println("子類對象的方法");        }        public   void method2(){            System.out.println("子類對象的方法2");        }    }
 
 
Instanceof運算符：
判斷前一個操作數(shù)通常是一個引用類型變量指向的對象，是否是后一個操作數(shù)通常是類、接口的本身或它的子類的實例。如果是返回true，否則返回false。
為了維護程序的健壯性，通常我們可以使用instanceof關(guān)鍵字來判斷類型關(guān)系。
class TestInstanceof{    publicstatic void main(String[] args){        Zi zi= new Zi();        //zi變量是Fu類型的對象的子類對象類型        booleanboo = zi instanceof Fu;        System.out.println(boo);        Fu fu= new Fu();               //fu變量是Fu類型的對象類型        boo =fu instanceof Fu;        System.out.println(boo);        boo =fu instanceof Zi;        System.out.println(boo);    }}class Fu{}class Zi extends Fu{}
在實際開發(fā)中常用的操作：
當(dāng)程序接收一個對象時，可能這個對象是來自外界的，我并不知道該對象是什么類型，那么如果我隨意把該對象直接拿來使用，可能就會出現(xiàn)錯誤，為了保證程序的安全，我需要在使用該對象是，使用instanceof運算符驗證該對象是否是我需要的對象。
 
靜態(tài)方法和成員變量在多態(tài)中的特性：
通常，在一個類中定義一個方法為static，那就是說，無需本類的對象即可調(diào)用此方法，關(guān)于static方法，聲明為static的方法有以下幾條限制：
它們僅能調(diào)用其他的static 方法。
它們只能訪問static數(shù)據(jù)。
它們不能以任何方式引用this 或super。 
無論是static修飾的變量，還是static修飾的方法，我們都知道他們是屬于類本身的，不是屬于某一個對象的，當(dāng)聲明一個對象時，并不產(chǎn)生static變量和方法的拷貝。也就是說，用static修飾的變量和方法在類加載的時候，將該信息存放到靜態(tài)區(qū)。
class DuoTai{    public static void main(String[] args){        /*            子類對象繼承父類對象，            但是不會繼承父類類型的靜態(tài)成員        */        Father father1 = new Child();        Father father2 = new Child();        System.out.println(father1.name);        father1.name= "劉禪";        //這里name是該類的靜態(tài)成員，直接屬于類，被所有對象共享        System.out.println(father2.name);        System.out.println(father1.name);        father1.laopo= "孫尚香";        father2.laopo= "小喬";        //非靜態(tài)成員屬于實例變量的，創(chuàng)建一個實例對象，就會生成一個laopo屬性        System.out.println(father1.laopo);        System.out.println(father2.laopo);    }}  class Father{    staticString name = "劉備";    Stringlaopo;    public void  method(){        System.out.println("父類對象的方法");    }}class Child extends Father{     public void method(){        System.out.println("子類對象的方法");    }}
注：這里要說明的時，當(dāng)子類沒有與之同名的static變量（或方法時），子類的對象也可以操控這塊內(nèi)存空間。
但是子類對象并沒有繼承父類中static修飾的變量和方法。因為static修飾的變量和方法是屬于父類本身的，父類靜態(tài)成員都不屬于父類對象，更不可能屬于子類對象，但是他們都可以訪問該屬性。
但是，當(dāng)存在繼承關(guān)系時，父類中有一個static修飾的變量（或方法），而子類中也存在一個同名的static修飾的變量（或方法）時，他們到底是否滿足“重寫”，而最終體現(xiàn)出多態(tài)的效果呢？？
下面來看一個例子。 父類中有一個static修飾的方法和一個普通的方法，子類中也有一個同名的static方法和一個普通的方法。如下
class DuoTai{    publicstatic void main(String[] args){        /*當(dāng)使用father調(diào)用method時候，發(fā)現(xiàn)執(zhí)行的是父類的靜態(tài)方法，并沒有存在多態(tài)特性        */        Fatherfather = new Child();        father.method();    }}
 
 
class Father{    public static void  method(){        System.out.println("父類對象的方法");    }}
class Child extends Father{     public static void method(){        System.out.println("子類對象的方法");    }}
 
 
從結(jié)果可以看出：對于靜態(tài)方法在子類中是不存在“重寫”這一說的，就像前面我們提到的，用static關(guān)鍵字修飾的方法和變量都是屬于類自己本身的，即使存在繼承關(guān)系，子類并沒有繼承父類的static修飾的變量和方法，所以說即使子類和父類中都有同樣的static方法和變量，他們是沒有任何關(guān)系的，他們是相互獨立的，他們是屬于各自類本身的。因此也是不存在多態(tài)特性的。而對于普通方法的調(diào)用是存在“重寫”而最終呈現(xiàn)出多態(tài)特性的，因為普通成員是屬于對象。
同樣的道理：對于static修飾的變量，當(dāng)子類與父類中存在相同的static變量時， 實際訪問的是屬于各自類的靜態(tài)數(shù)據(jù)。
多態(tài)是對象與對象之間的關(guān)系，與類、靜態(tài)成員無關(guān)。
而在父類和子類中對于非static方法，是根據(jù)“動態(tài)引用”來調(diào)用相應(yīng)的方法。
然而，接著會有這樣的問題存在：Java中子類不會繼承父類的static變量和static方法。
1）先說static方法：子類會不會繼承父類的static方法呢？？答案是：不會的，但是是可以訪問的。
2）接著來看父類的static修飾的變量，是否能夠被子類繼承呢？？ 答案：也是不可以的。但是也是可以被子類訪問的。
小結(jié)
1）子類是不繼承父類的static變量和方法的。因為這是屬于類本身的。但是子類是可以訪問的。 2）子類和父類中同名的static變量和方法都是相互獨立的，并不存在任何的重寫的關(guān)系。
多態(tài)：一個父類引用在不同時刻指向不同的子類對象，多態(tài)是針對對象而言，而static成員屬于類，不屬于對象，那么就不存在多態(tài)特性??！
 
 
總結(jié)：
成員變量 ：編譯看左邊（父類），運行看左邊（父類）.
 
   class DuoTai    {        public static void main(String[] args){            //編譯看左邊，運行看左邊            Father father  = new Child();                       //打印結(jié)果父類name            System.out.println(father.name);        }    }    class Father    {        String name = "父類name";    }    classChild extends Father    {        String name = "子類name";    }
 
成員方法 ：編譯看左邊（父類），運行看右邊（子類） 
  
  class DuoTai    {        public static void main(String[] args){            Fatherfather  = new Child();            //編譯看左邊，發(fā)現(xiàn)Father類沒有method2方法，報錯            //father.method2();            //運行看右邊，執(zhí)行的是Child對象的method方法            father.method();        }    }    class Father    {        public   void method(){            System.out.println("父類對象的方法");        }    }    class Child extends Father    {         public  void method(){            System.out.println("子類對象的方法");        }        public   void method2(){            System.out.println("子類對象的方法");        }    }
靜態(tài)方法：編譯看左邊（父類），運行看左邊（父類）
 
    class DuoTai    {        public static void main(String[] args){            Fatherfather  = new Child();            //編譯看左邊，發(fā)現(xiàn)Father有method方法            //運行看左邊，打印結(jié)果父類對象的方法            father.method();        }    }    class Father    {        public static  void method(){            System.out.println("父類對象的方法");        }    }    class Child extends Father    {         public static void method(){            System.out.println("子類對象的方法");        }    } 
繼承是實現(xiàn)類復(fù)用的重要手段，但是繼承帶來最大的一個壞處：破壞封裝性。相比之下，組合也是實現(xiàn)類復(fù)用的重要方式，而采用組合方式來實現(xiàn)類復(fù)用則能提供更好的封裝性。下面將詳細的介紹繼承和組合之間的聯(lián)系與區(qū)別。
1、使用繼承的注意點：
子類擴展父類時，子類可以從父類繼承到成員變量和方法，如果訪問權(quán)限可以，子類就可以直接訪問父類成員和方法，相當(dāng)于子類可以直接復(fù)用父類的成員，確實非常方便。
但是隨之帶來一個嚴重的問題，繼承嚴重的破壞了父類的封裝性。前面介紹封裝時提到：每個類都應(yīng)該封裝內(nèi)部信息和實現(xiàn)細節(jié)，而只是暴露必要的方法供其他類使用。但在繼承關(guān)系中，子類可以直接訪問父類的成員變量和方法，從而造成了子父類的嚴重耦合（依賴）。
從這個角度上看，父類的實現(xiàn)細節(jié)對子類不再透明，子類可以訪問父類的成員變量和方法，并且可重寫父類定義的方法，從而導(dǎo)致子類可以隨意篡改父類的方法。
為了保證父類良好的封裝性，不會被子類隨意改寫，設(shè)計父類通常尊徐如下規(guī)則：
盡量隱藏父類內(nèi)部數(shù)據(jù)，盡量把父類所有的成員變量都設(shè)置為private訪問類型，不要讓子類直接訪問父類的成員變量。
不要讓子類可以隨意訪問、修改父類的方法。父類中僅僅作為輔助其他方法的方法，應(yīng)該使用private訪問控制符修飾，讓子類無法訪問該方法，但又不想讓子類重寫該方法，那么可以使用final修飾符修飾該方法；如果希望父類某個方法被重寫，則用protected修飾。
盡量不要在父類構(gòu)造器中調(diào)用被子類重寫的方法。
·
final修飾的類不可以被繼承，final修飾的方法不可以被重寫，final修飾屬性不可以被改變（即常量）
 
組合：
使用private修飾的構(gòu)造器，從而保證子類無法調(diào)用該類的構(gòu)造器，也就無法繼承該類。當(dāng)然，可以提供公開的方法讓外界獲取該類型實例。
上面說明了繼承關(guān)系可能存在一些問題，以及如何處理這些問題。如果只是出于類復(fù)用的目的，就沒必要使用繼承了，完全可以使用組合來實現(xiàn)。
 
利用組合實現(xiàn)代碼復(fù)用
如果需要重復(fù)使用一個類，除了繼承之外，還可以把該類當(dāng)成另一個類的組合成分，從而允許新的類直接復(fù)用該類的public 方法。不管是繼承還是組合，都允許在新的類中直接復(fù)用舊類的方法。
如下代碼使用人繼承胳膊類，雖然達到了代碼的復(fù)用，但是嚴重的違反了事實！
class  ZuHe{    publicstatic void main(String[] args)    {        Personp = new Person();        p.play();    }}class Person extends Arm{   }class Arm{    publicvoid play(){        System.out.println("歡迎來到王者農(nóng)藥");    }}
 
我們可以更改一下方式，將胳膊作為一個組件，組合到人的身體上。
 
class  ZuHe{    publicstatic void main(String[] args)    {        Personp = new Person(new Arm());        p.play();    }}class Person{    privateArm arm;    publicPerson(Arm arm){        this.arm= arm;    }    publicvoid play(){        arm.play();        System.out.println("全軍出擊！");    }}class Arm{    publicvoid play(){        System.out.println("歡迎來到王者農(nóng)藥");    }}
 
對于繼承而言，子類可以直接獲取父類的public方法，程序使用子類時，將可以直接訪問該子類從父類哪里繼承到的方法；而組合則是將舊類對象作為新類對象的成員變量組合進來。用以實現(xiàn)新類的功能，用戶看到的是新類的方法，而不能看到被組合對象的方法。因此，通常需要在新類中使用private修飾被組合的舊類對象。
什么時候使用組合，什么時候使用繼承？
組合：當(dāng)描述的兩個對象，是組合關(guān)系，那就使用組合。
繼承：描述兩個對象的時候，這兩個對象邏輯上具有子父類關(guān)系，那就可以使用繼承描述這兩個對象。