Java面向對象(三) 【面向對象深刻：抽象類，接口，內部類等】

時間 2019-11-08

原文原文鏈接

面向對象(Object Oriented）java

一、抽象類抽象就是將擁有共同方法和屬性的對象提取出來。提取後，從新設計一個更加通用、更加大衆化的類，就叫抽象類。 1）abstract 關鍵字修飾類、方法，即抽象類和抽象方法。 2）抽象類能夠有具體的方法，或者所有都是具體方法，但一個類中只要有一個抽象方法，那麼這個類就是抽象類，而且必須用 abstract 修飾類。 3）抽象類只能用來被繼承，則子類必須實現抽象類中的所有抽象方法，不然子類也將是抽象類。抽象類也可主動繼承實體類。 4）抽象類不能實例化，即不能用 new 生成實例，因此只能做爲父類使用。 5）能夠聲明一個抽象類型的變量並指向具體子類的對象。 6）抽象類能夠實現接口中的方法。 7）抽象類中能夠不定義抽象方法，這樣作僅僅是不讓該類創建對象。編程

 1 //抽象類Animal
 2 abstract class Animal {
 3     abstract public void shout();  //抽象方法
 4 }
 5 class Cat extends Animal { 
 6     //子類必須實現父類的抽象方法，不然編譯錯誤
 7     public void shout() {
 8         System.out.println("喵喵喵！");
 9     }
10     // 定義本身的特有方法
11     public void CatchMouse(){
12         System.out.println("抓老鼠ing....");
13     }
14 }
15 //測試抽象類
16 public class AbstractTest {
17     public static void main(String[] args) {
18     Animal animal = new Cat();// 這樣new也是能夠的
19         Cat cat = new Cat();
20         cat.shout();
21         cat.seeDoor();
22     }
23 }

AbstractTest Code

疑問解答：一、抽象類中必定有抽象的方法？答：不對的。抽象類中能夠有抽象方法，也能夠沒有抽象方法。二、有抽象方法的類，必定是抽象類？答：對的。若是一個類中包含了至少一個抽象方法，那麼該類必須是抽象類。三、抽象類是否能夠用final 修飾？答：不能夠，final 的類不能當父類，abstract的類只能當父類。互斥的。不能同時使用。四、靜態方法是否能夠聲明成抽象方法？答：不能夠，static 和 abstract 也是互斥的。五、抽象方法是否可使用 private 修飾？答：不能夠。私有的方法不能子類繼承，不能繼承就不能重寫。抽象方法就是爲了讓子類實現重寫的。互斥的。六、抽象類中定義的抽象方法，每個抽象的方法都是定義了一個規則！！答：每個抽象方法，都是父類給實現的子類定義的一個規則：子類在實現父類抽象方法的時候，無論子類實現的細節如何，可是對實現的功能是有要求的。七、抽象關鍵字不能夠和那些關鍵字共存？ private => 非法的修飾符組合: abstract和private(抽象須要被覆蓋) static => 非法的修飾符組合: abstract和static final => 非法的修飾符組合: abstract和final 八、抽象類和非抽象類的區別？1）抽象類不能被實例化，非抽象類能夠實例化。
2）抽象類必須是有子類的，否則沒有定義該類的意義。非抽象類不必定了。若是final 修飾就必定沒有子類。
3）定義的方式不一樣。abstract 修飾抽象類。非抽象類不須要。
4）抽象類中能夠有抽象方法。非抽象類不能夠有抽象方法的。
二、接口（接口就是規範，定義的是一組規則。接口的出現將「多繼承」經過另外一種形式體現出來，即「多實現」）
接口相關規則：
• 接口中全部方法都是抽象的。
• 即便沒有顯式的將接口中的成員用public標示，也是public訪問類型的
• 接口中變量默認用 public static final標示，因此接口中定義的變量就是全局靜態常量。
• 能夠定義一個新接口，用extends去繼承一個已有的接口
• 能夠定義一個類，用implements去實現一個接口中全部方法。
• 能夠定義一個抽象類，用implements去實現一個接口中部分方法。
如何定義接口?
ide

如何實現接口？
• 子類經過implements來實現接口中的規範
• 接口不能建立實例，可是可用於聲明引用變量類型。
• 一個類實現了接口，必須實現接口中全部的方法，而且這些方法只能是public的。
• Java的類只支持單繼承，接口支持多繼承
接口的多繼承：接口徹底支持多繼承。和類的繼承相似，子接口擴展某個父接口，將會得到父接口中所定義的一切。
測試

examplethis

 1 package com.boom0831;
 2 /**
 3  * 測試接口和實現類
 4  * @author Administrator
 5  *
 6  */
 7 public class InterfaceTest {
 8 
 9     public static void main(String[] args) {
10         Volant v = new Angel();
11         v.fly();
12         
13         Honest h = new GoodMan();
14         h.helpOther();
15     }
16 
17 }
18 /**
19  * 飛行的接口
20  * @author Administrator
21  *
22  */
23 interface Volant{
24     int FLY_HEIGHT = 10000;
25     void fly();
26 }
27 // 善良的接口，天使接口
28 interface Honest{
29     void helpOther();
30 }
31 
32 // 天使實現了飛行和藹良的接口
33 class Angel implements Volant,Honest{ // 實現類能夠實現多個父接口
34     // 實現飛行的接口
35     @Override
36     public void fly() {
37         System.out.println("Angel.fly");
38     }
39     // 實現天使接口
40     @Override
41     public void helpOther() {
42         System.out.println("Angel.helpOther");
43     }
44 }
45 
46 /**
47  * 好人和壞人分別實現不一樣的接口
48  * @author Administrator
49  *
50  */
51 class GoodMan implements Honest{
52     @Override
53     public void helpOther() {
54         System.out.println("GoodMan.Honest");
55     }
56 }
57 
58 class Birdman implements Volant{
59     @Override
60     public void fly() {
61         System.out.println("Birdman.Volant");
62     }
63 }

InterfaceTest Code

example
spa

 1 package com.boom0831;
 2 
 3 public class UsbInterface {
 4 
 5     public static void main(String[] args) {
 6         Usb u1 = new Fan();
 7         u1.run();
 8         Usb u2 = new Keyboard();
 9         u2.run();
10         Usb u3 = new Mouse();
11         u3.run();
12     }
13 
14 }
15 interface Usb{
16     void run();
17 }
18 
19 class Fan implements Usb{
20     @Override
21     public void run() {
22         System.out.println("小風扇實現了USB接口。吹啊吹啊 個人驕傲放縱！");
23     }
24 }
25 
26 class Keyboard implements Usb{
27     @Override
28     public void run() {
29         System.out.println("鍵盤實現了USB接口。開始瘋狂的敲代碼！funk！");
30     }
31 }
32 
33 class Mouse implements Usb{
34     @Override
35     public void run() {
36         System.out.println("鼠標實現了USB接口。開始了蛇皮風騷走位！");
37     }
38 }

UsbInterface Code

example 升級版設計

 1 package com.boom0831;
 2 /**
 3  * UsbPlug多實現
 4  * @author Administrator
 5  *
 6  */
 7 public class ImplementTest {
 8 
 9     public static void main(String[] args) {
10         Computer computer = new Computer();
11         
12         Mouse mouse = new Mouse();
13         Keyboard keyboard = new Keyboard();
14         computer.load(mouse);
15         computer.load(keyboard);
16         
17         System.out.println("------ 擴展設備:小風扇 、 小檯燈 ------");
18         computer.load(new Fun());
19         computer.load(new Light());
20         
21     }
22 
23 }
24 
25 //經過usb 接口 給 設備供電的規則
26 interface UsbPlug{
27     /**
28      * 如何經過usb接口讓設備運轉起來的規則
29      */
30     void run();
31 }
32 
33 //功能描述的是 插槽如何和usb鏈接 通電
34 interface UsbSocket{
35     /**
36      * 插槽如何 鏈接 usb 插頭，給插頭通電
37      * @param plug  被裝備的 usb 插頭
38      */
39     void load(UsbPlug plug);
40 }
41 
42 //具備usb 功能的鼠標
43 class Mouse implements UsbPlug{
44     @Override
45     public void run() {
46         System.out.println("鼠標經過UsbPlug接口，鼠標通電成功，蛇皮走位操控電腦！");
47     }
48 }
49 
50 class Keyboard implements UsbPlug{
51     @Override
52     public void run() {
53         System.out.println("鍵盤經過UsbPlug接口，鍵盤通電成功，瘋狂敲代碼到崩潰！");
54         
55     }
56 }
57 
58 class Fun implements UsbPlug{
59     @Override
60     public void run() {
61         System.out.println("小風扇經過UsbPlug接口，小風扇通電成功，吹啊吹啊 個人驕傲放縱！");
62     }
63 }
64 
65 class Light implements UsbPlug{
66     @Override
67     public void run() {
68         System.out.println("小檯燈經過UsbPlug接口，小檯燈通電成功，發出奧特之光！");
69     }
70 }
71 
72  
73 class Computer implements UsbSocket{
74     // 電腦具備裝載UsbPlug接口的功能
75     public void load(UsbPlug plug){
76         plug.run();
77     }
78 }

Implement Code

三、內部類
　　在類內部定義的類爲成員內部類，在方法裏定義的類爲局部內部類，被 static 修飾的爲靜態內部類。一個類中可有多個內部類。
內部類的做用：
1. 因爲內部類提供了更好的封裝特性，而且能夠很方便的訪問外部類的屬性。因此，在只爲外部類提供服務的狀況下能夠優先考慮使用內部類。
2. 使用內部類間接實現多繼承：每一個內部類都能獨立地繼承一個類或者實現某些接口，因此不管外部類是否已經繼承了某個類或者實現了某些接口，對於內部類沒有任何影響。
.成員內部類(可使用private、default、protected、public任意進行修飾。類文件：外部類$內部類.class)

a) 非靜態內部類(外部類裏使用非靜態內部類和平時使用其餘類沒什麼不一樣)
i. 非靜態內部類必須寄存在一個外部類對象裏。若是有一個非靜態內部類對象那麼必定存在對應的外部類對象。非靜態內部類對象單獨屬於外部類的某個對象。
ii. 非靜態內部類能夠直接訪問外部類的成員，可是外部類不能直接訪問非靜態內部類成員。
iii. 非靜態內部類不能有靜態方法、靜態屬性和靜態初始化塊。
iv. 外部類的靜態方法、靜態代碼塊不能訪問非靜態內部類，包括不能使用非靜態內部類定義變量、建立實例。
v. 成員變量訪問要點：
1. 內部類裏方法的局部變量：變量名。
2. 內部類屬性：this.變量名。
3. 外部類屬性：外部類名.this.變量名。
4.建立內部類格式：外部類.內部類變量名 = new 外部類().new 內部類();
3d

 1 package com.boom.innerclass;
 2 
 3 /**
 4  * 測試非靜態內部類
 5  * 
 6  * @author Administrator
 7  *
 8  */
 9 public class InnerClass {
10 
11     public static void main(String[] args) {
12         // 建立內部類對象
13         Outer.Inner inner = new Outer().new Inner();
14         inner.show();
15     }
16 
17 }
18 
19 class Outer {
20     private int age = 10;
21 
22     public void testOuter() {
23 
24     }
25 
26     // 非靜態內部類Inner
27     class Inner {
28         int age = 30;
29 
30         public void show() {
31             int age = 40;
32             System.out.println("訪問外部內成員變量age:" + Outer.this.age);// 10
33             System.out.println("內部類內成員變量age:" + this.age); // 30
34             System.out.println("局部變量age:" + age);//40
35         }
36     }
37 }

View Code

b) 靜態內部類內部類前面被static關鍵字所修飾
1. 當一個靜態內部類對象存在，並不必定存在對應的外部類對象。靜態內部類的實例方法不能直接訪問外部類的實例方法。
2. 靜態內部類看作外部類的一個靜態成員。外部類的方法中能夠經過：「靜態內部類.名字」的方式訪問靜態內部類的靜態成員，經過 new 靜態內部類()訪問靜態內部類的實例。

c) 匿名內部類適合那種只須要使用一次的類,通常Android使用的較多。
1. 匿名內部類沒有訪問修飾符。
2. 匿名內部類沒有構造方法。由於它連名字都沒有那又何來構造方法.
• 只能實現一個接口，或者繼承一個父類
• 適合建立那種只須要一次使用的類，不能重複使用。比較常見的是在圖形界面編程GUI裏用獲得。
• 匿名內部類要使用外部類的局部變量，必須使用final修飾該局部變量
d) 局部內部類:定義在方法內部的，做用域只限於本方法，稱爲局部內部類。
　　局部內部類的的使用主要是用來解決比較複雜的問題，想建立一個類來輔助咱們的解決方案，到那時又不但願這個類是公共可用的，因此就產生了局部內部類。局部內部類和成員內部類同樣被編譯，只是它的做用域發生了改變，它只能在該方法中被使用，出了該方法就會失效。局部內部類在實際開發中應用不多。code