介面和多型

阿新 • • 發佈：2022-03-13

1.介面就是多個類的公共規範

介面是一種引用資料型別，最重要的內容就是其中的：抽象方法

如何定義一個介面的格式：

public interface 介面名稱{

}

備註：換成了關鍵字interface之後，編譯生成的位元組碼檔案仍然是：.java --> .class

如果是java7，那麼介面中可以包含的內容有：1.常量 2.抽象方法

java8,還可額外包含有：預設方法，靜態方法

java9.額外包含有：私有方法。

2.介面中抽象方法的定義：

 1 /*在任何java版本中，介面都能定義抽象方法。
 2 格式：
 3 public abstract 返回值型別 方法名稱（引數列表);
 
 4 
 5 注意事項：
 6 1.介面當中的抽象方法，修飾符必須是兩個固定關鍵字，public abstract
 7 2.這兩個關鍵字修飾符，可以選擇型省略，
 8 */
 9 public interface Demo01Interface {
10     //以下四種都是抽象方法
11     public abstract void methodAbs1();
12     abstract  void methodAbs2();
13     public void methodAbs3();
14     void methodAbs4();
15 }

3.介面抽象方法的使用

 1 public 
 interface Demo01Interface {
 2     //以下四種都是抽象方法
 3     public abstract void methodAbs1();
 4     abstract  void methodAbs2();
 5     public void methodAbs3();
 6     void methodAbs4();
 7 
 8 
 9 
10 public class MyInterfaceAbstractImpl implements Demo01Interface{
11 
12     @Override
13     public void 
 methodAbs1() {
14         System.out.println("這是第一個方法");
15     }
16 
17     @Override
18     public void methodAbs2() {
19         System.out.println("這是第二個方法");
20 
21     }
22 
23     @Override
24     public void methodAbs3() {
25         System.out.println("這是第三個方法");
26 
27     }
28 
29     @Override
30     public void methodAbs4() {
31         System.out.println("這是第四個方法");
32 
33     }
34 }
35 
36 
37 
38 介面的使用步驟：
39 1.介面不能直接使用，必須有一個“實現類”來“實現”該介面
40 格式：
41 public class 實現類名稱 implements 介面名稱{
42 
43 }
44 2.介面的實現類必須覆蓋重寫（實現）介面中所有的抽象方法
45 實現：去掉abstract關鍵字，加上方法體大括號。
46 3.建立實現類的物件，進行使用
47 注意事項：如果實現類並沒有覆蓋重寫介面中所有的抽象方法，那麼這個實現類自己必須是抽象類。
48 */
49 public class DemoInterface {
50     public static void main(String[] args) {
51         //錯誤寫法，不能直接new介面物件使用
52         //Demo01Interface demo = new Demo01Interface();
53         //建立實現類的物件使用
54         MyInterfaceAbstractImpl inter = new MyInterfaceAbstractImpl();
55         inter.methodAbs1();
56         inter.methodAbs2();
57         inter.methodAbs3();
58         inter.methodAbs4();
59 
60     }
61 }

4.介面的預設定義方法

 1 public interface InterfaceDefault {
 2     //抽象方法
 3     public abstract void methodAbs();
 4     //新增加了一個抽象方法
 5    // public abstract void methodAbs2();
 6 
 7     public default void methodDefault(){
 8         System.out.println("這是新新增的預設方法");
 9     }
10 
11 }
12 
13 
14 
15 
16 public class MyInterfaceDefaultA implements InterfaceDefault{
17     @Override
18     public void methodAbs(){
19         System.out.println("實現了抽象方法，AAA");
20     }
21 
22     @Override
23     public void methodDefault(){
24         System.out.println("實現類A覆蓋重寫了介面的預設方法");
25     }
26 
27 }
28 
29 
30 public class MyInterfaceDefaultB implements InterfaceDefault{
31 
32     @Override
33     public void methodAbs() {
34         System.out.println("實現了抽象方法：BBB");
35     }
36 }
37 
38 
39 public class Demo02Interface {
40     public static void main(String[] args) {
41         //建立了實現類物件
42         MyInterfaceDefaultA m = new MyInterfaceDefaultA();
43         //呼叫抽象方法，實際執行的是右側的實現類
44         m.methodAbs(); //實現了抽象方法，AAA
45 
46         //實現類A覆蓋重寫了介面的預設方法
47         m.methodDefault(); //實現類A覆蓋重寫了介面的預設方法
48         System.out.println("-----------------");
49 
50         MyInterfaceDefaultB m1 = new MyInterfaceDefaultB();
51         m1.methodAbs(); //實現了抽象方法：BBB
52         m1.methodDefault();//這是新新增的預設方法
53     }
54 }