面向對象(多態與內部類)

時間 2020-08-10

標籤面向對象部類欄目軟件設計简体版

原文原文鏈接

多態

多態的概述：多態是繼封裝，繼承以後，面向對象的第三大特性。是指同一行爲，具備多個不一樣表現形式，爲多態。html

舉個生活栗子：生活中，好比跑的動做，小貓、小狗和大象，跑起來是不同的。再好比飛的動做，昆蟲、鳥類和飛機，飛起來也是不同的。可見，同一行爲，經過不一樣的事物，能夠體現出來的不一樣的形態。多態，描述的就是這樣的狀態。java

java實現多態條件：

繼承：在多態中必須存在有繼承關係的子類和父類
重寫：子類對父類中某些方法進行從新定義，在調用這些方法時就會調用子類的方法
向上轉型：在多態中須要將子類的引用賦給父類對象，只有這樣該引用才既能能夠調用父類的方法，又能調用子類的方法

代碼簡略實現：程序員

public class Dome01 {
    public static void main(String[] args) {
        Fu fu = new Fu();  //建立父類對象
        fu.print();        //咱們能夠調用父類的公共方法print不能訪問name私有方法
        
        Zi zi = new Zi();  //建立子類對象
        zi.print();        //子類自動繼承父類的print()方法，可是子類裏也寫了一個print方法，因此屬於重寫父類方法
        zi.run();          //子類繼承父類可繼承的方法或變量，因此能夠經過子類調用run
        
        //多態----------------
        Fu zi2 = new Zi();    //建立子類對象，使用父類來承接
        zi2.print();          //和上面的子類對象調用同樣，上面子類能調用發下面也能調用
        zi.run();
    }
}

class Fu {// 定義父類方法
    public void print() {
        System.out.println("我是父類的輸出方法");
    }

    private void name() {
        System.out.println("我是父類的私有方法");
    }
    
    public void run() {
        System.out.println("我是父類的run方法");
    }
}

class Zi extends Fu { // 定義子類
    // 子類方法一
    @Override
    public void print() {
        System.out.println("我是子類的輸出方法");
    }

    private void name() {
        System.out.println("我是子類的私有方法");
    }

}

雖然使用下面多態調用效果同樣，可是調用的過程是有區別的算法

成員變量：編譯看左邊（父類），運行看左邊（父類）全部的成員變量取決於編譯時類型設計模式

成員方法：編譯看左邊（父類），運行看右邊（子類）全部的成員方法取決於運行時類型ide

靜態方法：編譯看左邊（父類），運行看左邊（父類）全部的靜態方法取決於編譯時類型學習

代碼解釋：spa

public class Dome02 {
    public static void main(String[] args) {
            Fu1 zi1 = new Zi1();
            System.out.println(zi1.a);  //輸出的值爲0,調用成員方法是編譯時看父類的成員變量，運行時也運行父類的成員變量
            zi1.name();  //調用成員方法時，編譯時，先看父類有沒有該成員方法，若是有，就去看子類有沒有，若是也有就執行子類的
            zi1.name2(); // 因爲name02是靜態方法，因此，調用時編譯是看的是父類，因此運行時也會運行父類的,
            
            
            //調用靜態方法和成員變量，靜態的是屬於各自類的不能繼承也不能被重寫
            Fu1.name2(); System.out.println(Fu1.b);
            Zi1.name2(); System.out.println(Zi1.b);
    }
}

class Fu1 {
    int a = 0;
    static int b = 1;

    public void name() {
        System.out.println("我是父類普通成員方法");
    }

    public static void name2() {
        System.out.println("我是父類靜態成員方法");
    }
}

class Zi1 extends Fu1 {
    int a = 22;
    static int b = 11;

    @Override
    public void name() {
        System.out.println("我是子類普通成員方法");
    }

    public static void name2() { // 靜態方法不能重寫
        System.out.println("我是子類的靜態成員方法");
    }
}

在調用成員方法時，子類若是沒有重寫，會默認繼承父類的，因此運行依舊子類中的name()方法，但本質上這個name()方法依舊是父類的，但子類重寫後，它的本質就變量，至關於子類從父類繼承來了一塊寶石，而後子類通過一系列的打磨，雕刻，它變成了一個工藝品，這個時候，這個工藝品就是子類獨有的而並不是仍是原來的那個寶石。注：父類的方法在子類重寫後仍能夠經過父類對象調用設計

多態的好處：可使程序編寫的更簡單，並有良好的擴展。

引用類型的轉型：

轉型分爲向上轉型和向下轉型兩種。code

向上轉型：多態自己是子類類型向父類類型向上轉換的過程，這個過程是默認的。當父類引用指向一個子類對象時，即是向上轉型。

父類類型 變量名 = new 子類類型(); 
如：Animal a = new Cat();

向下轉型：父類類型向子類類型向下轉換的過程，這個過程是強制的。一個已經向上轉型的子類對象，將父類引用轉爲子類引用，可使用強制類型轉換的格式，即是向下轉型。

子類類型 變量名 = (子類類型) 父類變量名; 
如:Cat c =(Cat) a;

instanceof關鍵字：

有時候，在轉換類型的時候，程序員會看不到源碼，因此咱們須要強轉時，不知道該往哪個子類去轉換，就會引起ClassCastException異常，爲了處理這一個問題java提供了instanceof關鍵字。（相似於判斷的意思）演示以下：

public class MyTest3 { 
    public static void main(String[] args) { 
        // 向上轉型 
        Animal a = new Cat(); 
        a.eat(); // 調用的是 Cat 的 eat 
        // 向下轉型 
        if (a instanceof Cat){ 
            Cat c = (Cat)a; 
            c.catchMouse(); // 調用的是 Cat 的 catchMouse 
        } else if (a instanceof Dog){ 
            Dog d = (Dog)a; 
            d.watchHouse(); // 調用的是 Dog 的 watchHouse 
        } 
    } 
}

內部類

內部類：顧名思義就是內部的類，在一個類A中定義一個類B這個時候類A就會被稱做外部類，而類B就被稱做內部類了。內部類，有根據所處位置不一樣，修飾符不一樣來區分爲四大內部類分別是：成員內部類靜態內部類局部內部類匿名內部類。

成員內部類：定義在類中方法外的類 ----代碼以下：

public class Outer {
    class Inner {
        // 成員內部類
    }
}

成員內部類的注意點：

內部類能夠直接訪問外部類的成員，包括私有成員。
外部類要訪問內部類的成員，必需要創建內部類的對象。

靜態內部類：靜態內部類是指使用 static 修飾的內部類。----代碼以下：

public class Outer {
    static class Inner {
        // 靜態內部類
    }
}

靜態內部類注意點：

在建立靜態內部類的實例時，不須要建立外部類的實例；
靜態內部類能夠直接訪問外部類的靜態成員，若是要訪問外部類的實例成員，則須要經過外部類的實例去訪問。

局部內部類：局部內部類是指在一個方法中局部位置定義的內部類。 ----代碼以下:

public class Outer {
    public void method() {
        class Inner {
            // 局部內部類
        }
    }
}

局部內部類注意點：

局部內部類與局部變量同樣，不能使用訪問控制修飾符（public、private 和 protected）和 static 修飾符修飾；
局部內部類只在當前方法中有效；
局部內部類中不能定義 static 成員。

匿名內部類：是內部類的簡化寫法，它的本質是一個帶具體實現的父類或者父接口的匿名的子類對象。 ----代碼以下：

匿名內部類前提：存在一個類或者接口，這裏的類能夠是具體類也能夠是抽象類。

public class Dome03 {
    public static void main(String[] args) {
        // 匿名內部類實現重寫普通類的方法
        new test01() {
            @Override
            public void name() {
                // TODO Auto-generated method stub
            }
        };
        // 匿名內部類實現重寫抽象類的抽象方法
        new test02() {
            @Override
            public void name() {
                // TODO Auto-generated method stub
            }
        };
        // 匿名內部類實現重寫接口的抽象方法
        new test03() {
            @Override
            public void name() {
                // TODO Auto-generated method stub
            }
        };
    }
}

class test01 {
    public void name() {
        System.out.println("");
    }
}

abstract class test02 {
    public abstract void name();
}

interface test03 {
    void name();
}

匿名內部類的做用：

開發中，最經常使用到的內部類就是匿名內部類了。以接口舉例，當你使用一個接口時，彷佛得作以下幾步操做，

定義子類
重寫接口方法
建立子類的對象
調用重寫後的方法

咱們的目的，最終只是爲了調用方法，那麼能不能簡化一下，把以上四步合成一步呢？匿名內部類就是作這樣的快捷方式。

模板設計模式

模板設計模式定義：定義一個操做中的算法骨架，將通用步驟以模板形式封裝在父類模板中，將具體細節步驟延遲到子類中實現。

如何理解，模板設計模式是將功能的細節封裝起來，給外界一個公共的調用模板，咱們調用這個模板就能達到想要的需求。好比：咱們想在控制檯打印三句話：我愛你java，我將好好學習java，我必定會成爲一個好的工程師。使用模板設計模式以下：

public class Dome04 {
    public static void main(String[] args) {
        Test test = new Test();
        test.template();   //調用時咱們不須要知道代碼實現的細節，直接調用模板方法就能完成需求
    }
}

class Test {
    // 細節是什麼？？？ 細節就是三句話
    public void template() { // 定義公共模板
        // 公共模板調用三個細節
        print1();
        print2();
        print3();
    }

    // 使用private封裝三個細節
    private void print1() {
        System.out.println("我愛你java");
    }

    private void print2() {
        System.out.println("我將好好學習java");
    }

    private void print3() {
        System.out.println("我必定會成爲一個好的工程師");
    }
}