【Java基本功】一文了解Java中繼承、封裝、多態的細節

本節主要介紹Java面向對象三大特性：繼承 封裝 多態，以及其中的原理。

本文會結合虛擬機對引用和對象的不一樣處理來介紹三大特性的原理。

繼承

Java中的繼承只能單繼承，可是能夠經過內部類繼承其餘類來實現多繼承。

<pre>

1. public class Son extends Father{
2. public void go () {
3. System.out.println("son go");
4. }
5. public void eat () {
6. System.out.println("son eat");
7. }
8. public void sleep() {
9. System.out.println("zzzzzz");
10. }
11. public void cook() {
12. //匿名內部類實現的多繼承
13. new Mother().cook();
14. //內部類繼承第二個父類來實現多繼承
15. Mom mom = new Mom();
16. mom.cook();
17. }
18. private class Mom extends Mother {
19. @Override
20. public void cook() {
21. System.out.println("mom cook");
22. }
23. }
24. }

封裝

封裝主要是由於Java有訪問權限的控制。public > protected > package = default > private。封裝能夠保護類中的信息，只提供想要被外界訪問的信息。

類的訪問範圍

1. A、public 包內、包外，全部類中可見
2. B、protected 包內全部類可見，包外有繼承關係的子類可見
3. (子類對象可調用)
4. C、(default)表示默認，不只本類訪問，並且是同包可。
5. D、private 僅在同一類中可見

</pre>

多態

多態通常能夠分爲兩種，一個是重寫，一個是重載。

1. 重寫是因爲繼承關係中的子類有一個和父類同名同參數的方法，會覆蓋掉父類的方法。重載是由於一個同名方法能夠傳入多個參數組合。
2. 注意，同名方法若是參數相同，即便返回值不一樣也是不能同時存在的，編譯會出錯。
3. 從jvm實現的角度來看，重寫又叫運行時多態，編譯時看不出子類調用的是哪一個方法，可是運行時操做數棧會先根據子類的引用去子類的類信息中查找方法，找不到的話再到父類的類信息中查找方法。
4. 而重載則是編譯時多態，由於編譯期就能夠肯定傳入的參數組合，決定調用的具體方法是哪個了。

向上轉型和向下轉型：

1. public static void main(String[] args) {
2. Son son = new Son();
3. //首先先明確一點，轉型指的是左側引用的改變。
4. //father引用類型是Father，指向Son實例，就是向上轉型，既能夠使用子類的方法，也能夠使用父類的方法。
5. //向上轉型,此時運行father的方法
6. Father father = son;
7. father.smoke();
8. //不能使用子類獨有的方法。
9. // father.play();編譯會報錯
10. father.drive();
11. //Son類型的引用指向Father的實例，因此是向下轉型，不能使用子類非重寫的方法，能夠使用父類的方法。
12. //向下轉型，此時運行了son的方法
13. Son son1 = (Son) father;
14. //轉型後就是一個正常的Son實例
15. son1.play();
16. son1.drive();
17. son1.smoke();
18. //由於向下轉型以前必須先經歷向上轉型。
19. //在向下轉型過程當中，分爲兩種狀況：
20. //狀況一：若是父類引用的對象若是引用的是指向的子類對象，
21. //那麼在向下轉型的過程當中是安全的。也就是編譯是不會出錯誤的。
22. //由於運行期Son實例確實有這些方法
23. Father f1 = new Son();
24. Son s1 = (Son) f1;
25. s1.smoke();
26. s1.drive();
27. s1.play();
28. //狀況二：若是父類引用的對象是父類自己，那麼在向下轉型的過程當中是不安全的，編譯不會出錯，
29. //可是運行時會出現java.lang.ClassCastException錯誤。它能夠使用instanceof來避免出錯此類錯誤。
30. //由於運行期Father實例並無這些方法。
31. Father f2 = new Father();
32. Son s2 = (Son) f2;
33. s2.drive();
34. s2.smoke();
35. s2.play();
36. //向下轉型和向上轉型的應用，有些人以爲這個操做沒意義，何須先向上轉型再向下轉型呢，不是畫蛇添足麼。其實能夠用於方法參數中的類型聚合，而後具體操做再進行分解。
37. //好比add方法用List引用類型做爲參數傳入，傳入具體類時經歷了向下轉型
38. add(new LinkedList());
39. add(new ArrayList());
40. //總結
41. //向上轉型和向下轉型都是針對引用的轉型，是編譯期進行的轉型，根據引用類型來判斷使用哪一個方法
42. //而且在傳入方法時會自動進行轉型（有須要的話）。運行期將引用指向實例，若是是不安全的轉型則會報錯。
43. //若安全則繼續執行方法。
44. }
45. public static void add(List list) {
46. System.out.println(list);
47. //在操做具體集合時又經歷了向上轉型
48. //        ArrayList arr = (ArrayList) list;
49. //        LinkedList link = (LinkedList) list;
50. }

總結： 向上轉型和向下轉型都是針對引用的轉型，是編譯期進行的轉型，根據引用類型來判斷使用哪一個方法。而且在傳入方法時會自動進行轉型（有須要的話）。運行期將引用指向實例，若是是不安全的轉型則會報錯，若安全則繼續執行方法。

編譯期的靜態分派

其實就是根據引用類型來調用對應方法。

<pre>

1. public static void main(String[] args) {
2. Father father= new Son();
3. 靜態分派 a= new 靜態分派();
4. //編譯期肯定引用類型爲Father。
5. //因此調用的是第一個方法。
6. a.play(father);
7. //向下轉型後，引用類型爲Son，此時調用第二個方法。
8. //因此，編譯期只肯定了引用，運行期再進行實例化。
9. a.play((Son)father);
10. //當沒有Son引用類型的方法時，會自動向上轉型調用第一個方法。
11. a.smoke(father);
12. //
13. }
14. public void smoke(Father father) {
15. System.out.println("father smoke");
16. }
17. public void play (Father father) {
18. System.out.println("father");
19. //father.drive();
20. }
21. public void play (Son son) {
22. System.out.println("son");
23. //son.drive();
24. }

</pre>

方法重載優先級匹配

<pre>

1. public static void main(String[] args) {
2. 方法重載優先級匹配 a = new 方法重載優先級匹配();
3. //普通的重載通常就是同名方法不一樣參數。
4. //這裏咱們來討論當同名方法只有一個參數時的狀況。
5. //此時會調用char參數的方法。
6. //當沒有char參數的方法。會調用int類型的方法，若是沒有int就調用long
7. //即存在一個調用順序char -> int -> long ->double -> ..。
8. //當沒有基本類型對應的方法時，先自動裝箱，調用包裝類方法。
9. //若是沒有包裝類方法，則調用包裝類實現的接口的方法。
10. //最後再調用持有多個參數的char...方法。
11. a.eat('a');
12. a.eat('a','c','b');
13. }
14. public void eat(short i) {
15. System.out.println("short");
16. }
17. public void eat(int i) {
18. System.out.println("int");
19. }
20. public void eat(double i) {
21. System.out.println("double");
22. }
23. public void eat(long i) {
24. System.out.println("long");
25. }
26. public void eat(Character c) {
27. System.out.println("Character");
28. }
29. public void eat(Comparable c) {
30. System.out.println("Comparable");
31. }
32. public void eat(char ... c) {
33. System.out.println(Arrays.toString(c));
34. System.out.println("...");
35. }
36. //    public void eat(char i) {
37. //        System.out.println("char");
38. //    }