多型
多型的概述：多型是繼封裝，繼承之后，面向物件的第三大特性，是指同一行為，具有多個不同表現形式，為多型，
舉個生活栗子：生活中，比如跑的動作，小貓、小狗和大象，跑起來是不一樣的，再比如飛的動作，昆蟲、鳥類和飛機，飛起來也是不一樣的，可見，同一行為，通過不同的事物，可以體現出來的不同的形態，多型，描述的就是這樣的狀態，
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("我是子類的私有方法"); } }
雖然使用下面多型呼叫效果一樣，但是呼叫的程序是有區別的
-
成員變數：編譯看左邊（父類），運行看左邊（父類） 所有的成員變數取決于編譯時型別
-
成員方法：編譯看左邊（父類），運行看右邊（子類） 所有的成員方法取決于運行時型別
-
靜態方法：編譯看左邊（父類），運行看左邊（父類） 所有的靜態方法取決于編譯時型別
代碼解釋：
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()方法依舊是父類的，但子類重寫后，它的本質就變數，相當于子類從父類繼承來了一塊寶石，然后子類經過一系列的打磨，雕刻，它變成了一個工藝品，這個時候，這個工藝品就是子類獨有的而并非還是原來的那個寶石，注：父類的方法在子類重寫后仍可以通過父類物件呼叫
多型的好處： 可以使程式撰寫的更簡單，并有良好的擴展，
參考型別的轉型：
轉型分為向上轉型和向下轉型兩種，
向上轉型 ：多型本身是子型別別向父型別別向上轉換的程序，這個程序是默認的，當父類參考指向一個子類物件時，便是向上轉型，
父型別別 變數名 = 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("我一定會成為一個好的工程師"); } }
設計模式，屬于一種寫代碼的思想，這里寫很是簡略，與個人學習有出入，是自己所理解的比較容易懂一些，了解更多細節：https://www.runoob.com/design-pattern/template-pattern.html
個人學習，內容簡略
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/91752.html
標籤：Java