摘要：接口的概念接口的概念接口是功能的集合，同樣可看做是一種數(shù)據(jù)類型，是比抽象類更為抽象的類。多態(tài)的前提是必須有子父類關(guān)系或者類實現(xiàn)接口關(guān)系，否則無法完成多態(tài)。

* A:接口的概念
    接口是功能的集合，同樣可看做是一種數(shù)據(jù)類型，是比抽象類更為抽象的”類”。
    接口只描述所應(yīng)該具備的方法，并沒有具體實現(xiàn)，具體的實現(xiàn)由接口的實現(xiàn)類(相當(dāng)于接口的子類)來完成。這樣將功能的定義與實現(xiàn)分離，優(yōu)化了程序設(shè)計。
    請記?。阂磺惺挛锞泄δ?，即一切事物均有接口。

* A: 接口的定義
        與定義類的class不同，接口定義時需要使用interface關(guān)鍵字。
        定義接口所在的仍為.java文件，雖然聲明時使用的為interface關(guān)鍵字的編譯后仍然會產(chǎn)生.class文件。這點(diǎn)可以讓我們將接口看做是一種只包含了功能聲明的特殊類。

                            
* B : 定義格式
        public interface 接口名 {
            抽象方法1;
            抽象方法2;
            抽象方法3;
        }
* C: 定義步驟
        使用interface代替了原來的class，其他步驟與定義類相同：
        接口中的方法均為公共訪問的抽象方法
        接口中無法定義普通的成員變量

* A: 類與接口的關(guān)系
        類與接口的關(guān)系為實現(xiàn)關(guān)系，即類實現(xiàn)接口。實現(xiàn)的動作類似繼承，只是關(guān)鍵字不同，實現(xiàn)使用implements。
        其他類(實現(xiàn)類)實現(xiàn)接口后，就相當(dāng)于聲明：”我應(yīng)該具備這個接口中的功能”。實現(xiàn)類仍然需要重寫方法以實現(xiàn)具體的功能。
* B: 類實現(xiàn)接口的格式
        class 類 implements 接口 {
            重寫接口中方法
        } 
* C:注意事項
         在類實現(xiàn)接口后，該類就會將接口中的抽象方法繼承過來，此時該類需要重寫該抽象方法，完成具體的邏輯。
        接口中定義功能，當(dāng)需要具有該功能時，可以讓類實現(xiàn)該接口，只聲明了應(yīng)該具備該方法，是功能的聲明。
        在具體實現(xiàn)類中重寫方法，實現(xiàn)功能，是方法的具體實現(xiàn)。

* A:成員變量特點(diǎn)
     * a 接口中可以定義變量，但是變量必須有固定的修飾符修飾，public static final 所以接口中的變量也稱之為常量，其值不能改變。后面我們會講解static與final關(guān)鍵字
        

* B:案例
        interface Demo { ///定義一個名稱為Demo的接口。
            public static final int NUM = 3;// NUM的值不能改變
        }
        
    

* A: 成員方法特點(diǎn)
    * a 接口中可以定義方法，方法也有固定的修飾符，public abstract
    * b 子類必須覆蓋掉接口中所有的抽象方法后，子類才可以實例化。否則子類是一個抽象類。

* B: 案例
        interface Demo { ///定義一個名稱為Demo的接口。
            public abstract void show1();
            public abstract void show2();
        }
        
        //定義子類去覆蓋接口中的方法。類與接口之間的關(guān)系是 實現(xiàn)。通過 關(guān)鍵字 implements
        class DemoImpl implements Demo { //子類實現(xiàn)Demo接口。
            //重寫接口中的方法。
            public void show1(){}
            public void show2(){}
        }

A: 接口的實現(xiàn)類
   一個類如果實現(xiàn)類接口,有兩種操作方法:
   第一:實現(xiàn)類是非抽象類,就需要重寫接口中所有的抽象方法.
   第二:實現(xiàn)類也聲明為抽象類,那么實現(xiàn)類可以不重寫接口中的抽象方法。

==============================第二節(jié)課開始====================================

* A：接口的多實現(xiàn)
    了解了接口的特點(diǎn)后，那么想想為什么要定義接口，使用抽象類描述也沒有問題，接口到底有啥用呢？
    接口最重要的體現(xiàn)：解決多繼承的弊端。將多繼承這種機(jī)制在java中通過多實現(xiàn)完成了。
    
* B 多實現(xiàn)的優(yōu)點(diǎn)
    * 怎么解決多繼承的弊端呢？
    * 弊端：多繼承時，當(dāng)多個父類中有相同功能時，子類調(diào)用會產(chǎn)生不確定性。
    * 其實核心原因就是在于多繼承父類中功能有主體，而導(dǎo)致調(diào)用運(yùn)行時，不確定運(yùn)行哪個主體內(nèi)容。
    * 為什么多實現(xiàn)能解決了呢？
    * 因為接口中的功能都沒有方法體，由子類來明確。

* C :案例演示
    interface Fu2{
        void show2();
    }
    class Zi implements Fu1,Fu2 {    // 多實現(xiàn)。同時實現(xiàn)多個接口。
        public void show1(){}
        public void show2(){}
    }
    

* A: 繼承的同時實現(xiàn)接口
    * 接口和類之間可以通過實現(xiàn)產(chǎn)生關(guān)系，同時也學(xué)習(xí)了類與類之間可以通過繼承產(chǎn)生關(guān)系。當(dāng)一個類已經(jīng)繼承了一個父類，它又需要擴(kuò)展額外的功能，這時接口就派上用場了。
    * 子類通過繼承父類擴(kuò)展功能，通過繼承擴(kuò)展的功能都是子類應(yīng)該具備的基礎(chǔ)功能。如果子類想要繼續(xù)擴(kuò)展其他類中的功能呢？這時通過實現(xiàn)接口來完成。
    * 接口的出現(xiàn)避免了單繼承的局限性。父類中定義的事物的基本功能。接口中定義的事物的擴(kuò)展功能。
    
* B: 代碼演示
    class Fu {
        public void show(){}
    }
    interface Inter {
        pulbic abstract void show1();
    }
    class Zi extends Fu implements Inter {
        public void show1() {
        }
    }

    接口的出現(xiàn)避免了單繼承的局限性。父類中定義的事物的基本功能。接口中定義的事物的擴(kuò)展功能。
    

* A: 接口的多繼承
    * 學(xué)習(xí)類的時候，知道類與類之間可以通過繼承產(chǎn)生關(guān)系，接口和類之間可以通過實現(xiàn)產(chǎn)生關(guān)系，那么接口與接口之間會有什么關(guān)系。
    * 多個接口之間可以使用extends進(jìn)行繼承。
    
* B 代碼演示
     interface Fu1{
        void show();
    }
    interface Fu2{
        void show1();
    }
    interface Fu3{
        void show2();
    }
    interface Zi extends Fu1,Fu2,Fu3{
        void show3();
    }
    
    在開發(fā)中如果多個接口中存在相同方法，這時若有個類實現(xiàn)了這些接口，那么就要實現(xiàn)接口中的方法，由于接口中的方法是抽象方法，子類實現(xiàn)后也不會發(fā)生調(diào)用的不確定性。

* A:接口的思想
    * 前面學(xué)習(xí)了接口的代碼體現(xiàn)，現(xiàn)在來學(xué)習(xí)接口的思想，接下里從生活中的例子進(jìn)行說明。
    * 舉例：我們都知道電腦上留有很多個插口，而這些插口可以插入相應(yīng)的設(shè)備，這些設(shè)備為什么能插在上面呢？
    * 主要原因是這些設(shè)備在生產(chǎn)的時候符合了這個插口的使用規(guī)則，否則將無法插入接口中，更無法使用。發(fā)現(xiàn)這個插口的出現(xiàn)讓我們使用更多的設(shè)備。

* B: 接口的好處    
    * 總結(jié)：接口在開發(fā)中的它好處
    * 1、接口的出現(xiàn)擴(kuò)展了功能。
    * 2、接口其實就是暴漏出來的規(guī)則。
    * 3、接口的出現(xiàn)降低了耦合性，即設(shè)備與設(shè)備之間實現(xiàn)了解耦。
    
    * 接口的出現(xiàn)方便后期使用和維護(hù)，一方是在使用接口（如電腦），一方在實現(xiàn)接口（插在插口上的設(shè)備）。例如：筆記本使用這個規(guī)則（接口），電腦外圍設(shè)備實現(xiàn)這個規(guī)則（接口）。

* A: 明白了接口思想和接口的用法后，接口和抽象類的區(qū)別是什么呢？接口在生活體現(xiàn)也基本掌握，那在程序中接口是如何體現(xiàn)的呢？
    通過實例進(jìn)行分析和代碼演示抽象類和接口的用法。
* B: 舉例：
    *    犬：
            行為：
            吼叫；
            吃飯；
    * 緝毒犬：
            行為：
            吼叫；
            吃飯；
            緝毒；

* C:思考：
    * 由于犬分為很多種類，他們吼叫和吃飯的方式不一樣，在描述的時候不能具體化，也就是吼叫和吃飯的行為不能明確。
    * 當(dāng)描述行為時，行為的具體動作不能明確，這時，可以將這個行為寫為抽象行為，那么這個類也就是抽象類。
    * 可是當(dāng)緝毒犬有其他額外功能時，而這個功能并不在這個事物的體系中。這時可以讓緝毒犬具備犬科自身特點(diǎn)的同時也有其他額外功能，可以將這個額外功能定義接口中。

* D: 代碼演示
    interface 緝毒{
        public abstract void 緝毒();
    }
    //定義犬科的這個提醒的共性功能
    abstract class 犬科{
    public abstract void 吃飯();
    public abstract void 吼叫();
    }
    // 緝毒犬屬于犬科一種，讓其繼承犬科，獲取的犬科的特性，
    //由于緝毒犬具有緝毒功能，那么它只要實現(xiàn)緝毒接口即可，這樣即保證緝毒犬具備犬科的特性，也擁有了緝毒的功能
    class 緝毒犬 extends 犬科 implements 緝毒{
    
        public void 緝毒() {
        }
        void 吃飯() {
        }
        void 吼叫() {
        }
    }
    class 緝毒豬 implements 緝毒{
        public void 緝毒() {
        }
    }

* E: 接口和抽象類區(qū)別總結(jié)
     相同點(diǎn):
        都位于繼承的頂端,用于被其他類實現(xiàn)或繼承;
        都不能直接實例化對象;
        都包含抽象方法,其子類都必須覆寫這些抽象方法;
    區(qū)別:
        抽象類為部分方法提供實現(xiàn),避免子類重復(fù)實現(xiàn)這些方法,提高代碼重用性;接口只能包含抽象方法;
        一個類只能繼承一個直接父類(可能是抽象類),卻可以實現(xiàn)多個接口;(接口彌補(bǔ)了Java的單繼承)
        抽象類是這個事物中應(yīng)該具備的你內(nèi)容, 繼承體系是一種 is..a關(guān)系
        接口是這個事物中的額外內(nèi)容,繼承體系是一種 like..a關(guān)系
    
    二者的選用:
        優(yōu)先選用接口,盡量少用抽象類;
        需要定義子類的行為,又要為子類提供共性功能時才選用抽象類;
    

==============================第三節(jié)課開始====================================

* A: 多態(tài)概述
    多態(tài)是繼封裝、繼承之后，面向?qū)ο蟮牡谌筇匦浴?    現(xiàn)實事物經(jīng)常會體現(xiàn)出多種形態(tài)，如學(xué)生，學(xué)生是人的一種，則一個具體的同學(xué)張三既是學(xué)生也是人，即出現(xiàn)兩種形態(tài)。    
    Java作為面向?qū)ο蟮恼Z言，同樣可以描述一個事物的多種形態(tài)。如Student類繼承了Person類，一個Student的對象便既是Student，又是Person。
    Java中多態(tài)的代碼體現(xiàn)在一個子類對象(實現(xiàn)類對象)既可以給這個子類(實現(xiàn)類對象)引用變量賦值，又可以給這個子類(實現(xiàn)類對象)的父類(接口)變量賦值。
    如Student類可以為Person類的子類。那么一個Student對象既可以賦值給一個Student類型的引用，也可以賦值給一個Person類型的引用。
    最終多態(tài)體現(xiàn)為父類引用變量可以指向子類對象。
    多態(tài)的前提是必須有子父類關(guān)系或者類實現(xiàn)接口關(guān)系，否則無法完成多態(tài)。
    在使用多態(tài)后的父類引用變量調(diào)用方法時，會調(diào)用子類重寫后的方法。

* A:多態(tài)的定義格式：
    * 就是父類的引用變量指向子類對象
         父類類型  變量名 = new 子類類型();
         變量名.方法名();
    
* B: 普通類多態(tài)定義的格式
        父類 變量名 = new 子類();
        舉例：    
            class Fu {}
            class Zi extends Fu {}
            //類的多態(tài)使用
            Fu f = new Zi();
* C: 抽象類多態(tài)定義格式            
        抽象類 變量名 = new 抽象類子類();
        舉例：    
        abstract class Fu {
                 public abstract void method();
                 }
        class Zi extends Fu {
        public void method(){
                      System.out.println(“重寫父類抽象方法”);
        }
        }
        //類的多態(tài)使用
        Fu fu= new Zi();
* D: 接口多態(tài)定義的格式
        接口 變量名 = new 接口實現(xiàn)類();
        如： interface Fu {
                     public abstract void method();
        }
        class Zi implements Fu {
                     public void method(){
                      System.out.println(“重寫接口抽象方法”);
        }
        }
        //接口的多態(tài)使用
        Fu fu = new Zi();
* E: 注意事項
        同一個父類的方法會被不同的子類重寫。在調(diào)用方法時，調(diào)用的為各個子類重寫后的方法。
        如 Person p1 = new Student();
           Person p2 = new Teacher();
           p1.work(); //p1會調(diào)用Student類中重寫的work方法
           p2.work(); //p2會調(diào)用Teacher類中重寫的work方法
        當(dāng)變量名指向不同的子類對象時，由于每個子類重寫父類方法的內(nèi)容不同，所以會調(diào)用不同的方法。

* A: 掌握了多態(tài)的基本使用后，那么多態(tài)出現(xiàn)后類的成員有啥變化呢？前面學(xué)習(xí)繼承時，我們知道子父類之間成員變量有了自己的特定變化，
    * 那么當(dāng)多態(tài)出現(xiàn)后，成員變量在使用上有沒有變化呢？
    * 多態(tài)出現(xiàn)后會導(dǎo)致子父類中的成員變量有微弱的變化

* B: 代碼演示
    class Fu {
        int num = 4;
    }
    class Zi extends Fu {
        int num = 5;
    }
    class Demo {
        public static void main(String[] args)     {
            Fu f = new Zi();
            System.out.println(f.num);
            Zi z = new Zi();
            System.out.println(z.num);
        }
    }

* C: 多態(tài)成員變量
    當(dāng)子父類中出現(xiàn)同名的成員變量時，多態(tài)調(diào)用該變量時：
    編譯時期：參考的是引用型變量所屬的類中是否有被調(diào)用的成員變量。沒有，編譯失敗。
    運(yùn)行時期：也是調(diào)用引用型變量所屬的類中的成員變量。
    簡單記：編譯和運(yùn)行都參考等號的左邊。編譯運(yùn)行看左邊。

* D: 多態(tài)出現(xiàn)后會導(dǎo)致子父類中的成員方法有微弱的變化?？慈缦麓a
    class Fu {
        int num = 4;
        void show()    {
            System.out.println("Fu show num");
        }
    }
    class Zi extends Fu {
        int num = 5;
        void show()    {
            System.out.println("Zi show num");
        }
    }
    class Demo {
        public static void main(String[] args)     {
            Fu f = new Zi();
            f.show();
        }
    }

* E: 多態(tài)成員方法
    編譯時期：參考引用變量所屬的類，如果沒有類中沒有調(diào)用的方法，編譯失敗。
    運(yùn)行時期：參考引用變量所指的對象所屬的類，并運(yùn)行對象所屬類中的成員方法。
    簡而言之：編譯看左邊，運(yùn)行看右邊。

* A: 作用
     可以通過instanceof關(guān)鍵字來判斷某個對象是否屬于某種數(shù)據(jù)類型。如學(xué)生的對象屬于學(xué)生類，學(xué)生的對象也屬于人類

* 格式:
    boolean  b  = 對象  instanceof  數(shù)據(jù)類型;

* 舉例:
    Person p1 = new Student(); // 前提條件，學(xué)生類已經(jīng)繼承了人類
    boolean flag = p1 instanceof Student; //flag結(jié)果為true
    boolean flag2 = p2 instanceof Teacher; //flag結(jié)果為false

* A: 多態(tài)的轉(zhuǎn)型分為向上轉(zhuǎn)型與向下轉(zhuǎn)型兩種：
    
* B: 向上轉(zhuǎn)型：當(dāng)有子類對象賦值給一個父類引用時，便是向上轉(zhuǎn)型，多態(tài)本身就是向上轉(zhuǎn)型的過程。
    使用格式：
    父類類型  變量名 = new 子類類型();
    如：Person p = new Student();

==============================第四節(jié)課開始====================================

* A: 向下轉(zhuǎn)型：一個已經(jīng)向上轉(zhuǎn)型的子類對象可以使用強(qiáng)制類型轉(zhuǎn)換的格式，將父類引用轉(zhuǎn)為子類引用，這個過程是向下轉(zhuǎn)型。如果是直接創(chuàng)建父類對象，是無法向下轉(zhuǎn)型的！
    使用格式：
    子類類型 變量名 = (子類類型) 父類類型的變量;
    如:Student stu = (Student) p;  //變量p 實際上指向Student對象
    

* A: 多態(tài)的好處和弊端
    * 當(dāng)父類的引用指向子類對象時，就發(fā)生了向上轉(zhuǎn)型，即把子類類型對象轉(zhuǎn)成了父類類型。
      向上轉(zhuǎn)型的好處是隱藏了子類類型，提高了代碼的擴(kuò)展性。
    * 但向上轉(zhuǎn)型也有弊端，只能使用父類共性的內(nèi)容，而無法使用子類特有功能，功能有限制。
    
* B: 看如下代碼
    //描述動物類，并抽取共性eat方法
    abstract class Animal {
        abstract void eat();
    }
     
    // 描述狗類，繼承動物類，重寫eat方法，增加lookHome方法
    class Dog extends Animal {
        void eat() {
            System.out.println("啃骨頭");
        }
    
        void lookHome() {
            System.out.println("看家");
        }
    }
    
    // 描述貓類，繼承動物類，重寫eat方法，增加catchMouse方法
    class Cat extends Animal {
        void eat() {
            System.out.println("吃魚");
        }
    
        void catchMouse() {
            System.out.println("抓老鼠");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Animal a = new Dog(); //多態(tài)形式，創(chuàng)建一個狗對象
            a.eat(); // 調(diào)用對象中的方法，會執(zhí)行狗類中的eat方法
            // a.lookHome();//使用Dog類特有的方法，需要向下轉(zhuǎn)型，不能直接使用
            
            // 為了使用狗類的lookHome方法，需要向下轉(zhuǎn)型
    // 向下轉(zhuǎn)型過程中，可能會發(fā)生類型轉(zhuǎn)換的錯誤，即ClassCastException異常
            // 那么，在轉(zhuǎn)之前需要做健壯性判斷 
            if( !a instanceof Dog){ // 判斷當(dāng)前對象是否是Dog類型
                     System.out.println("類型不匹配，不能轉(zhuǎn)換"); 
                     return; 
            } 
            Dog d = (Dog) a; //向下轉(zhuǎn)型
            d.lookHome();//調(diào)用狗類的lookHome方法
        }
    }

* C 多態(tài)總結(jié):
    什么時候使用向上轉(zhuǎn)型：
        當(dāng)不需要面對子類類型時，通過提高擴(kuò)展性，或者使用父類的功能就能完成相應(yīng)的操作，這時就可以使用向上轉(zhuǎn)型。
        如：Animal a = new Dog();
            a.eat();
    什么時候使用向下轉(zhuǎn)型
        當(dāng)要使用子類特有功能時，就需要使用向下轉(zhuǎn)型。
            如：Dog d = (Dog) a; //向下轉(zhuǎn)型
                d.lookHome();//調(diào)用狗類的lookHome方法
            向下轉(zhuǎn)型的好處：可以使用子類特有功能。
            弊端是：需要面對具體的子類對象；在向下轉(zhuǎn)型時容易發(fā)生ClassCastException類型轉(zhuǎn)換異常。在轉(zhuǎn)換之前必須做類型判斷。
        如：if( !a instanceof Dog){…}

 * A: 畢老師和畢姥爺?shù)墓适? * 案例:
  /*
    描述畢老師和畢姥爺，
    畢老師擁有講課和看電影功能
    畢姥爺擁有講課和釣魚功能
  */
    class 畢姥爺 {
        void 講課() {
            System.out.println("政治");
        }
    
        void 釣魚() {
            System.out.println("釣魚");
        }
    }
    
    // 畢老師繼承了畢姥爺，就有擁有了畢姥爺?shù)闹v課和釣魚的功能，
    // 但畢老師和畢姥爺?shù)闹v課內(nèi)容不一樣，因此畢老師要覆蓋畢姥爺?shù)闹v課功能
    class 畢老師 extends 畢姥爺 {
        void 講課() {
            System.out.println("Java");
        }
    
        void 看電影() {
            System.out.println("看電影");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            // 多態(tài)形式
            畢姥爺 a = new 畢老師(); // 向上轉(zhuǎn)型
            a.講課(); // 這里表象是畢姥爺，其實真正講課的仍然是畢老師，因此調(diào)用的也是畢老師的講課功能
            a.釣魚(); // 這里表象是畢姥爺，但對象其實是畢老師，而畢老師繼承了畢姥爺，即畢老師也具有釣魚功能
    
            // 當(dāng)要調(diào)用畢老師特有的看電影功能時，就必須進(jìn)行類型轉(zhuǎn)換
            畢老師 b = (畢老師) a; // 向下轉(zhuǎn)型
            b.看電影();
        }
    

 * A:案例介紹
     * 定義USB接口（具備開啟功能、關(guān)閉功能），筆記本要使用USB設(shè)備，即筆記本在生產(chǎn)時需要預(yù)留可以插入USB設(shè)備的USB接口，即就是筆記本具備使用USB設(shè)備的功能，
     * 但具體是什么USB設(shè)備，筆記本并不關(guān)心，只要符合USB規(guī)格的設(shè)備都可以。鼠標(biāo)和鍵盤要想能在電腦上使用，那么鼠標(biāo)和鍵盤也必須遵守USB規(guī)范，不然鼠標(biāo)和鍵盤的生產(chǎn)出來無法使用
    * 進(jìn)行描述筆記本類，實現(xiàn)筆記本使用USB鼠標(biāo)、USB鍵盤
        USB接口，包含開啟功能、關(guān)閉功能
        筆記本類，包含運(yùn)行功能、關(guān)機(jī)功能、使用USB設(shè)備功能
        鼠標(biāo)類，要符合USB接口
        鍵盤類，要符合USB接口

* B: 案例分析
    * 階段一：
        使用筆記本，筆記本有運(yùn)行功能，需要筆記本對象來運(yùn)行這個功能
    * 階段二：
        想使用一個鼠標(biāo)，又有一個功能使用鼠標(biāo)，并多了一個鼠標(biāo)對象。
    * 階段三：
        還想使用一個鍵盤 ，又要多一個功能和一個對象
    * 問題：每多一個功能就需要在筆記本對象中定義一個方法，不爽，程序擴(kuò)展性極差。
        降低鼠標(biāo)、鍵盤等外圍設(shè)備和筆記本電腦的耦合性。

 * A: 代碼實現(xiàn)
    定義鼠標(biāo)、鍵盤，筆記本三者之間應(yīng)該遵守的規(guī)則
    interface USB {
        void open();// 開啟功能
    
        void close();// 關(guān)閉功能
    }
    
        鼠標(biāo)實現(xiàn)USB規(guī)則
    class Mouse implements USB {
        public void open() {
            System.out.println("鼠標(biāo)開啟");
        }
    
        public void close() {
            System.out.println("鼠標(biāo)關(guān)閉");
        }
    }
    
        鍵盤實現(xiàn)USB規(guī)則
    class KeyBoard implements USB {
        public void open() {
            System.out.println("鍵盤開啟");
        }
    
        public void close() {
            System.out.println("鍵盤關(guān)閉");
        }
    }
    
        定義筆記本
    class NoteBook {
        // 筆記本開啟運(yùn)行功能
        public void run() {
            System.out.println("筆記本運(yùn)行");
        }
    
        // 筆記本使用usb設(shè)備，這時當(dāng)筆記本對象調(diào)用這個功能時，必須給其傳遞一個符合USB規(guī)則的USB設(shè)備
        public void useUSB(USB usb) {
            // 判斷是否有USB設(shè)備
            if (usb != null) {
                usb.open();
                usb.close();
            }
        }
    
        public void shutDown() {
            System.out.println("筆記本關(guān)閉");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            // 創(chuàng)建筆記本實體對象
            NoteBook nb = new NoteBook();
            // 筆記本開啟
            nb.run();
    
            // 創(chuàng)建鼠標(biāo)實體對象
            Mouse m = new Mouse();
            // 筆記本使用鼠標(biāo)
            nb.useUSB(m);
    
            // 創(chuàng)建鍵盤實體對象
            KeyBoard kb = new KeyBoard();
            // 筆記本使用鍵盤
            nb.useUSB(kb);
    
            // 筆記本關(guān)閉
            nb.shutDown();
        }
    }

* 把今天的知識點(diǎn)總結(jié)一遍。