了解物件導向程式設計 (OOP)

物件導向程式設計 (OOP) 是 Java 中的一個基本概念，它使創建模組化、可重複使用和可擴展的程式碼變得更加容易。在這篇文章中，我們將探討 OOP 的核心原則，例如類別、物件、繼承、封裝、多態性和抽象。

1.物件導向程式設計簡介

OOP 是一種基於「物件」概念的程式設計範例，它可以包含資料和操作該資料的方法。透過將程式碼組織成對象，您可以建立更易於管理且更易於理解的程式。

OOP 的四個關鍵原則是：

• 封裝
• 繼承
• 多態性
• 抽象

讓我們在 Java 環境中探索每個概念。

2.類別與物件

2.1 什麼是類別？

Java中的類別是建立物件的藍圖。它定義了從類別建立的物件將具有的屬性（欄位）和行為（方法）。將類別視為概述物件的結構和功能的範本。

類別範例：

public class Car {
    // Fields (attributes)
    String mark;
    String model;
    int year;

    // Method (behavior)
    void startEngine() {
        System.out.println("Engine started.");
    }
}

在此範例中，Car 類別有三個欄位：mark、model 和 Year，以及一個方法 startEngine()。

2.2 什麼是物件？

物件是類別的實例。定義類別後，您可以從中建立多個對象，每個對像都有自己唯一的欄位值。

建立物件的範例：

public class Main {
    public static void main(String[] args) {
        // Creating an object of the Car class
        Car myCar = new Car();

        // Setting field values
        myCar.mark = "Toyota";
        myCar.model = "Corolla";
        myCar.year = 2021;

        // Calling a method
        myCar.startEngine();  // Outputs: Engine started.
    }
}

在此範例中，myCar 是 Car 類別的對象，並為其欄位分配了特定值。

挑戰1：
建立一個名為 Book 的類，其中包含標題、作者和頁數字段。建立 Book 類別的對象，設定其字段，並列印出書籍的詳細資訊。

3.封裝

封裝是將資料（欄位）和對資料進行操作的方法捆綁到單一單元或類別中，並限制對某些物件組件的存取的做法。這是透過使用存取修飾符（私有、公有、受保護）來實現的。

封裝有助於保護物件的內部狀態免受意外幹擾和誤用。

封裝範例：

public class Person {
    // Private fields
    private String name;
    private int age;

    // Public methods to access private fields
    public String getName() {
        return name;
    }

    public void setName(String newName) {
        name = newName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int newAge) {
        if (newAge > 0) {
            age = newAge;
        }
    }
}

在此範例中，Person 類別透過將其欄位設為私有來封裝其字段，並提供公用方法（getName、setName、getAge、setAge）來存取和修改這些欄位。

挑戰2：
透過將欄位設為私有並為每個欄位建立公用 getter 和 setter 方法，為 Book 類別新增封裝。

4.繼承

繼承是一種允許一個類別繼承另一個類別的屬性和方法的機制。繼承的類別稱為“子類別”或“子類別”，繼承的類別稱為“超類別”或“父類別”。

繼承提高了程式碼的可重用性並在類別之間建立了自然的層次結構。

繼承範例：

// Superclass
public class Animal {
    void eat() {
        System.out.println("This animal is eating.");
    }
}

// Subclass
public class Dog extends Animal {
    void bark() {
        System.out.println("The dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();  // Inherited method from Animal class
        myDog.bark(); // Method from Dog class
    }
}

在此範例中，Dog 類別繼承了 Animal 類別的 eat 方法，並且還擁有自己的方法 bark。

挑戰3：
建立一個繼承自 Book 類別的子類別 EBook。將新欄位 fileSize 和方法 download() 新增至 EBook 類別。

5.多態性

多態允許不同類別的物件被視為公共超類別的物件。可以透過方法重寫和介面來實現。

5.1 方法重寫

方法重寫允許子類別提供其超類別中已定義的方法的特定實作。

多態性範例：

public class Animal {
    void sound() {
        System.out.println("This animal makes a sound.");
    }
}

public class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("The cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Cat(); // Polymorphism
        myAnimal.sound();  // Outputs: The cat meows.
    }
}

在這個例子中，儘管 myAnimal 是 Animal 類型，但它引用的是 Cat 類型的對象，並且呼叫了 Cat 的重寫聲音方法。

挑戰4：
重寫 Book 類別中的 toString 方法以傳回書籍詳細資訊的字串表示形式。

6.抽象

抽象涉及隱藏系統複雜的實作細節並僅公開必要的部分。可以使用抽象類別和介面來實作。

6.1 抽象類別

抽象類別無法實例化，並且可能包含必須由子類別實現的抽象方法（沒有主體的方法）。

抽象範例：

abstract class Shape {
    abstract void draw();  // Abstract method
}

public class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape myShape = new Circle();
        myShape.draw();  // Outputs: Drawing a circle.
    }
}

在這個例子中，Shape是一個抽象類，有一個抽象方法draw，它是由Circle類別實作的。

挑戰5：
使用抽象方法 powerOn 建立一個抽象類別 Device。建立一個實作 powerOn 方法的 Smartphone 子類別。

7.總結

在這篇文章中，我們探討了 Java 中物件導向程式設計的關鍵概念：類別、物件、繼承、封裝、多態性與抽象。理解這些原則對於建立複雜且高效的 Java 應用程式至關重要。

請隨意嘗試提供的範例和挑戰。如果您有任何疑問或需要進一步說明，請在下面發表評論！

以上是了解物件導向程式設計 (OOP)的詳細內容。更多資訊請關注PHP中文網其他相關文章！