用 Java 破解 OOP：一個你想要的 PIE

在這篇文章中，我們將探討 Java 中物件導向程式設計 (OOP) 的四個基本支柱。這些核心原則有助於建立模組化、可重複使用和可維護的程式碼。這篇文章作為介紹，即將推出的條目將透過細緻的討論和範例深入探討每個概念。

為了方便記憶，請使用縮寫「A PIE」：A抽象，P多態性，I繼承，以及E封裝。

---

物件導向意味著什麼？

Java 通常被描述為物件導向的語言，但它並不是 100% 物件導向的。 為什麼？ 雖然Java 中的大多數元素都圍繞著物件（如類別、物件和方法），但它也使用原始類型（如int、boolean 和double），它們是不是物體。

在 Java 中保留原始類型是一個經過深思熟慮的設計選擇。原因如下：

• 記憶體效率： 與對應的物件（如整數或布林值）相比，原始型別佔用 較少的記憶體。

• 效能提升：基元上的操作更快，因為它們避免了物件建立和引用管理的開銷。

• 方便：原始型別讓簡單情況下的程式碼更簡潔，尤其是在處理算術和邏輯運算時。

簡而言之，Java 透過提供效能和記憶體效率的原語來實現平衡，同時還提供包裝類別（如Integer），以便您需要將這些值視為對象時。

---

1. 抽象：隱藏不必要的細節

抽象表示隱藏內部邏輯並僅向使用者公開基本功能。它允許用戶在高層與物件交互，而無需擔心底層複雜性。可以將其視為使用ATM——您只需輸入要提款的金額，而不需要知道ATM如何與您的銀行互動來處理交易。

在Java中，抽象類別和介面透過定義基本方法並將內部細節留給子類別或父類別來幫助實現抽象但對用戶隱藏。

例子：

abstract class Payment {
    // A method with concrete logic, hidden from the user.
    private void authenticate() {
        System.out.println("Authenticating payment...");
    }

    // Abstract method that child classes must implement.
    abstract void processPayment(double amount);

    // Public method exposing only the necessary details.
    public void makePayment(double amount) {
        authenticate();  // Hidden complexity
        processPayment(amount);  // Exposed to child classes
        System.out.println("Payment completed.");
    }
}

// Concrete class implementing the abstract method.
class CreditCardPayment extends Payment {
    @Override
    void processPayment(double amount) {
        System.out.println("Processing credit card payment of ₹" + amount);
    }
}

public class TestAbstraction {
    public static void main(String[] args) {
        Payment payment = new CreditCardPayment(); // Polymorphism in action.
        payment.makePayment(1000.00);  // Only high-level interaction.
    }
}

解釋：

• 複雜性隱藏在哪裡？

  • authenticate() 方法代表內部邏輯（例如，使用者驗證、加密），對於子類別和使用者來說都是私有且隱藏的。
  • makePayment() 方法是唯一可供使用者使用的公共方法，提供了一種與支付系統互動的簡單方法。

• 抽象類別有什麼幫助？

  • 它強制子類別（如CreditCardPayment）實作核心邏輯（processPayment()），但子類別不需要了解驗證邏輯－它在父類別中處理。

• 使用者看到了什麼？

  • 從使用者的角度來看，他們只與 makePayment() 互動－他們不關心 身分驗證或信用卡付款內部如何運作。

---

2. 多態性：相同的動作，不同的形式

多態允許物件在不同情況下表現不同。 Java 支援兩種類型的多態：

1。編譯時多態（方法重載）：透過定義多個同名但參數不同的方法來實現。

例子：

abstract class Payment {
    // A method with concrete logic, hidden from the user.
    private void authenticate() {
        System.out.println("Authenticating payment...");
    }

    // Abstract method that child classes must implement.
    abstract void processPayment(double amount);

    // Public method exposing only the necessary details.
    public void makePayment(double amount) {
        authenticate();  // Hidden complexity
        processPayment(amount);  // Exposed to child classes
        System.out.println("Payment completed.");
    }
}

// Concrete class implementing the abstract method.
class CreditCardPayment extends Payment {
    @Override
    void processPayment(double amount) {
        System.out.println("Processing credit card payment of ₹" + amount);
    }
}

public class TestAbstraction {
    public static void main(String[] args) {
        Payment payment = new CreditCardPayment(); // Polymorphism in action.
        payment.makePayment(1000.00);  // Only high-level interaction.
    }
}

2。運行時多態性（方法重寫）： 當子類別提供父類別中聲明的方法的特定實作時實作。

例子：

class Calculator {
    // Compile-time polymorphism (Overloading)
    int add(int a, int b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(2, 3));  // Output: 5
        System.out.println(calc.add(2, 3, 4));  // Output: 9
    }
}

解釋：

編譯時多態性透過重載add()方法來展示，而運行時多態性透過重寫sound()方法來演示。

sound() 方法 根據物件類型的不同，其行為也有所不同。雖然animal是Animal類型，但在運行時，會執行Dog中重寫的方法。

---

3. 繼承：透過父子關係實作程式碼可重複使用

繼承允許類別（子）重複使用另一個類別（父）的屬性和行為。這可以提高程式碼可重複使用性並在類別之間建立IS-A關係。 Java 不支援透過類別多重繼承以避免歧義，但允許透過介面實作。

例子：

class Animal {
    void sound() {
        System.out.println("Animals make sounds.");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks.");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal animal = new Dog();  // Runtime polymorphism
        animal.sound();  // Output: Dog barks
    }
}

解釋：

在此範例中：

• 狗繼承自 Animal，這表示狗既能吃又吠。

• 這示範了程式碼重用——我們不需要重寫 Dog 類別的 eat() 方法。

---

4. 封裝：透過存取控制保護資料

封裝意味著將資料（欄位）和操作它的方法捆綁到一個單元（類別）中。 它也透過將欄位設為私有並公開它們來確保資料隱藏透過 getter 和 setter。

例子：

abstract class Payment {
    // A method with concrete logic, hidden from the user.
    private void authenticate() {
        System.out.println("Authenticating payment...");
    }

    // Abstract method that child classes must implement.
    abstract void processPayment(double amount);

    // Public method exposing only the necessary details.
    public void makePayment(double amount) {
        authenticate();  // Hidden complexity
        processPayment(amount);  // Exposed to child classes
        System.out.println("Payment completed.");
    }
}

// Concrete class implementing the abstract method.
class CreditCardPayment extends Payment {
    @Override
    void processPayment(double amount) {
        System.out.println("Processing credit card payment of ₹" + amount);
    }
}

public class TestAbstraction {
    public static void main(String[] args) {
        Payment payment = new CreditCardPayment(); // Polymorphism in action.
        payment.makePayment(1000.00);  // Only high-level interaction.
    }
}

解釋：

• 名稱欄位是私有的，這表示它不能直接從類別外部存取。

• 透過公有 getter 和 setter 提供存取權限，強制資料隱藏。

---

結論

Java 的 OOP 原則—抽象、多態、繼承和封裝—構成了編寫模組化、可維護和高效程式碼的基礎。掌握了這些概念，您將能夠更好地準備設計和理解複雜的系統。

在接下來的文章中，我們將透過更細緻的範例、最佳實踐和以面試為重點的技巧，更深入地探討這些原則。敬請關注！

---

相關貼文

• Java 基礎

• 陣列面試重點

• Java 記憶體基礎

• Java 關鍵字要點

• 集合架構重點

編碼快樂！

以上是用 Java 破解 OOP：一個你想要的 PIE的詳細內容。更多資訊請關注PHP中文網其他相關文章！