Java 中的介面與抽象類

介面和抽象類別是實現抽象和多態性的基本元件。

什麼是介面？

Java中的介面是一種參考類型，類似類，只能包含抽象方法、靜態方法、預設方法和靜態最終變數（常數）。 Java 中介面用於實作抽象和多重繼承。接口不能直接實例化。

?在 Java 8 之前，介面只能有 抽象方法。
這些方法的實作必須在單獨的類別中提供。因此，如果要在介面中新增方法，則必須在實作相同介面的類別中提供其實作程式碼。

？ 為了解決這個問題，Java 8引入了預設方法的概念，它允許介面擁有具有實現的方法，而不會影響實現該介面的類別.

如果需要，可以透過實作類別來覆寫預設方法。

介面的主要特性

• 抽象方法：沒有主體的方法，使用abstract關鍵字宣告。
• 預設方法：具有主體的方法，在 Java 8 中引入，允許介面提供預設實作。
• 靜態方法：屬於介面本身的方法，不屬於介面實例。
• 常數：宣告為靜態和最終的變量，它們是隱式公共的。

什麼是抽象類別？

Java中的抽象類別是不能自行實例化的類，可以包含抽象方法（沒有主體的方法）和具體方法（有主體的方法）。抽象類別用於為子類別提供公共基礎，允許程式碼重複使用和共享行為的定義。

抽象類別的主要特徵

• 抽象方法：沒有主體的方法，使用abstract關鍵字宣告。
• 具體方法：帶有主體的方法，提供預設實作。
• 建構子：抽象類別可以有建構函數，但不能直接實例化。
• 實例變數：抽象類別可以有實例變數和靜態變數。

介面和抽象類別之間的區別

多重繼承

• 介面：Java透過介面支援多重繼承，允許一個類別實作多個介面。
• 抽象類別：Java不支援類別的多重繼承，也就是一個類別只能擴充一個抽象類別。

方法體

• 介面：在 Java 8 之前，介面不能包含方法體。在 Java 8 中，預設方法和靜態方法可以有主體。
• 抽象類別：抽象類別可以包含抽象方法（不含主體）和具體方法（帶主體）。

變數

• 介面：介面中的變數隱式是公共的、靜態的、最終的。
• 抽象類別：抽象類別可以有實例變數、靜態變數和常數。

用法

• 介面：非常適合定義多個類別可以實現的契約。
• 抽象類別：適合為一系列相關類別提供公共基礎，共享程式碼和行為。

Java 的繼承方法

Java只支援單繼承，也就是每個類別只能繼承一個類別的欄位和方法。如果您需要從多個來源繼承屬性，Java 提供了介面的概念，它是多重繼承的一種形式。

?介面與類別類似。但是，它們僅定義方法的簽名，而不定義其實作。接口中聲明的方法在類別中實作。 多重繼承當一個類別實作多個介面時就會發生。

在Java中，多重繼承是透過介面而不是類別來實現的。這允許一個類別實作多個接口，並從每個接口繼承方法簽名。下面是一個使用介面示範多重繼承的範例。

使用介面的多重繼承範例

讓我們定義兩個接口，Flyable 和 Swimmable，以及一個實現這兩個接口的 Duck 類。

接口：可飛行

public interface Flyable {
    void fly();
}

接口：可游泳

public interface Swimmable {
    void swim();
}

類別： 鴨類

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

解釋

1. 介面：

   • Flyable介面定義了一個方法fly()。
   • Swimmable介面定義了一個方法swim()。

2. 班級:

   • Duck 類別實作了 Flyable 和 Swimmable 介面。
   • Duck 類別提供了 Fly() 和 Swim() 方法的實作。

3. 主要方法:

   • 建立了一個 Duck 實例。
   • fly() 和 Swim() 方法在 Duck 實例上調用，表示 Duck 類別繼承了這兩個介面的行為。

輸出

Duck is flying
Duck is swimming

這裡用一個簡單的圖來說明這種關係：

+----------------+
|    Flyable     |Interface
|----------------|
| + fly()        |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|     Duck       |Class
|----------------|
| + fly()        |
| + swim()       |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|   Swimmable    |Interface
|----------------|
| + swim()       |
+----------------+

在此範例中，Duck 類別透過實作 Flyable 和 Swimmable 介面來示範多重繼承。這允許 Duck 類別繼承並提供兩個介面中定義的方法的實現，展示了 Java 如何透過介面實現多重繼承。

---

Java中的抽象類別

Java 中的抽象類別用於為一系列相關類別提供公共基礎。它們可以包含抽象方法（沒有主體的方法）和具體方法（有主體的方法）。下面是一個示範抽象類別使用的範例。

抽象類別的範例

讓我們定義一個抽象類別 Animal 和兩個擴展 Animal 類別的子類別 Dog 和 Cat。

抽象類別：動物

public abstract class Animal {
    // Abstract method (does not have a body)
    public abstract void makeSound();

    // Concrete method (has a body)
    public void sleep() {
        System.out.println("The animal is sleeping");
    }
}

子類：狗

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog says: Woof!");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.sleep();
    }
}

子類：貓

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat says: Meow!");
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();
        cat.sleep();
    }
}

解釋

1. 抽象類：動物

   • Animal 類別被宣告為抽象類，這表示它不能直接實例化。
   • 它包含一個抽象方法 makeSound()，該方法必須由任何子類別實作。
   • 它也包含一個具體的方法 sleep()，它提供了預設實作。

2. 子類：狗

   • Dog 類別擴展了 Animal 類別。
   • 它提供了抽象方法 makeSound() 的實作。
   • main方法建立一個Dog實例並呼叫makeSound()和sleep()方法。

3. 子類：貓

   • Cat 類別擴展了 Animal 類別。
   • 它提供了抽象方法 makeSound() 的實作。
   • main方法建立一個Cat實例並呼叫makeSound()和sleep()方法。

輸出

對於狗類：

public interface Flyable {
    void fly();
}

對於貓：

public interface Swimmable {
    void swim();
}

這裡用一個簡單的圖來說明這種關係：

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

在此範例中，Animal 抽象類別為 Dog 和 Cat 子類別提供了公共基礎。 Animal 類別定義了一個必須由任何子類別實作的抽象方法 makeSound() 和一個提供預設實作的具體方法 sleep()。 Dog 和 Cat 類別擴展了 Animal 類別並提供了它們自己的 makeSound() 方法的實作。

介面要點

1. 抽象：Java中的介面是一種實作抽象的機制。
2. 預設方法：預設情況下，介面方法是抽象且公共的。
3. 方法類型：介面方法只能是 public、private、abstract、default、static 和 strictfp。
4. 欄位類型：介面欄位（變數）只能是 public、static 或 Final。
5. IS-A關係：Java介面也代表IS-A關係。
6. 實例化：不能直接實例化，就像抽象類別一樣。
7. 鬆散耦合：可以用來實現鬆散耦合
8. 隱式抽象：每個介面都是隱式抽象的。
9. 預設方法：預設方法僅在介面中允許。

Duck is flying
Duck is swimming

實際應用

使用介面

介面通常用於定義 API、框架和函式庫。例如，java.util.List介面提供了列表實作的契約，例如ArrayList和LinkedList。

+----------------+
|    Flyable     |Interface
|----------------|
| + fly()        |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|     Duck       |Class
|----------------|
| + fly()        |
| + swim()       |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|   Swimmable    |Interface
|----------------|
| + swim()       |
+----------------+

使用抽象類別

抽象類別通常用於為一系列相關類別提供基底類別。例如，java.util.AbstractList類別提供了List介面的骨架實現，減少了子類別需要實現的程式碼量。

public interface Flyable {
    void fly();
}

---

介面和抽象類別之間的區別

SNo	Interface	Abstract Class
1	Interfaces cannot be instantiated	Abstract classes cannot be instantiated
2	It can have both abstract and non-abstract methods	It can have both abstract and non-abstract methods
3	In interfaces, all fields are automatically public, static, and final, and all methods that you declare or define (as default methods) are public	In abstract classes, you can declare fields that are not static and final, and define public, protected, and private concrete methods
4	Interface supports multiple inheritance. Multiple interfaces can be implemented	Abstract class or class can extend only one class
5	It is used if you expect that unrelated classes would implement your interface. Eg, the interfaces Comparable and Cloneable are implemented by many unrelated classes	It is used if you want to share code among several closely related classes
6	It is used if you want to specify the behavior of a particular data type, but not concerned about who implements its behavior.	It is used if you expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private)

參考：https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
當抽象類別被子類別化時，子類別通常為其父類別中的所有抽象方法提供實作。但是，如果沒有，則子類別也必須聲明為抽象的。

---

專家意見

根據《Effective Java》的作者 Joshua Bloch 的說法，在定義類型時，介面比抽象類別更受青睞，因為它們更靈活並且支援多重繼承。然而，抽象類別對於提供共享功能和減少程式碼重複很有用。

「介面非常適合定義 mixins。相較之下，類別非常適合定義具有內在屬性的物件。」

• 約書亞·布洛赫

亮點

• 介面：非常適合定義契約和支援多重繼承。
• 抽象類別：適合為相關類別提供公共基礎，共享程式碼和行為。
• 區別：介面只能有抽象方法（Java 8 之前），而抽象類別可以同時有抽象方法和具體方法。
• 用法：介面用於定義API和框架，而抽象類別用於提供骨架實作。

進一步探索

在您自己的 Java 專案中探索介面和抽象類別的強大功能。嘗試使用介面定義合約並使用抽象類別提供共享功能。與 Java 社群分享您的見解和經驗，為集體知識和成長做出貢獻。

歡迎對本文進行任何更正或補充。

public interface Flyable {
    void fly();
}

以上是Java 中的介面與抽象類的詳細內容。更多資訊請關注PHP中文網其他相關文章！