Java類、封裝、繼承的方法

Java類、封裝、繼承的方法

1. Java類

在Java中，類是面向對象編程的基本構建塊。類是一個模板或藍圖，用于創建對象。類定義了對象的屬性和行為。屬性是類的成員變量，行為是類的方法。

1.1 類的定義

一個類通常由以下幾個部分組成：

• 類名：類的名稱，遵循大駝峰命名法（CamelCase）。
• 成員變量：類的屬性，也稱為字段或實例變量。
• 方法：類的行為，定義了對象可以執行的操作。
• 構造方法：用于創建類的對象，通常用于初始化成員變量。

public class Car {
    // 成員變量
    private String brand;
    private String color;
    private int speed;

    // 構造方法
    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
        this.speed = 0;
    }

    // 方法
    public void accelerate(int increment) {
        speed += increment;
    }

    public void brake(int decrement) {
        speed -= decrement;
    }

    public void displayInfo() {
        System.out.println("Brand: " + brand + ", Color: " + color + ", Speed: " + speed);
    }
}

1.2 創建對象

通過new關鍵字可以創建類的對象。創建對象時，會調用類的構造方法。

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Red");
        myCar.accelerate(30);
        myCar.displayInfo();
    }
}

2. 封裝

封裝是面向對象編程的三大特性之一（另外兩個是繼承和多態）。封裝的主要目的是隱藏對象的內部狀態，并控制對對象的訪問。通過封裝，可以防止外部代碼直接訪問對象的內部數據，從而提高代碼的安全性和可維護性。

2.1 訪問修飾符

Java提供了四種訪問修飾符來控制類、變量、方法和構造方法的訪問權限：

• private：只能在類內部訪問。
• default（默認，不使用任何修飾符）：只能在同一個包內訪問。
• protected：可以在同一個包內以及子類中訪問。
• public：可以在任何地方訪問。

2.2 封裝的實現

通過將類的成員變量聲明為private，并提供公共的getter和setter方法來訪問和修改這些變量，可以實現封裝。

public class Person {
    private String name;
    private int age;

    // Getter方法
    public String getName() {
        return name;
    }

    // Setter方法
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("Invalid age");
        }
    }
}

2.3 封裝的好處

• 數據隱藏：外部代碼無法直接訪問對象的內部數據，只能通過公共方法訪問。
• 數據驗證：可以在setter方法中添加數據驗證邏輯，確保數據的有效性。
• 代碼維護：封裝使得代碼更易于維護和修改，因為內部實現的改變不會影響外部代碼。

3. 繼承

繼承是面向對象編程的另一個重要特性。通過繼承，一個類可以繼承另一個類的屬性和方法，從而實現代碼的重用和擴展。

3.1 繼承的實現

在Java中，使用extends關鍵字來實現繼承。子類（派生類）繼承父類（基類）的屬性和方法。

// 父類
public class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// 子類
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println("Woof! Woof!");
    }
}

3.2 方法重寫

子類可以重寫父類的方法，以提供不同的實現。重寫的方法必須具有相同的名稱、參數列表和返回類型。

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(getName() + " is eating fish.");
    }
}

3.3 繼承的好處

• 代碼重用：子類可以繼承父類的屬性和方法，避免重復代碼。
• 代碼擴展：子類可以在繼承的基礎上添加新的屬性和方法，或者重寫父類的方法。
• 多態：繼承是實現多態的基礎，允許子類對象以父類類型進行引用。

4. 總結

Java中的類、封裝和繼承是面向對象編程的核心概念。類定義了對象的模板，封裝隱藏了對象的內部實現并提供了安全的訪問方式，繼承則實現了代碼的重用和擴展。通過合理使用這些特性，可以編寫出結構清晰、易于維護的Java程序。