Java類與對象

Java是一種面向對象的編程語言，類是其中最基本的概念之一。在Java中，一個類包含了一組屬性和方法，描述了一類對象的共同特徵和功能。Java中的對象是根據類創建的，每個對象都擁有各自獨特的狀態和行為。

一、類的定義和使用

定義一個類，需要使用關鍵字class，類名一般使用首字母大寫的駝峰命名法，類名之後的代碼塊稱為類體，包含了屬性和方法的定義。

public class Person {
    // 成員變量：姓名、年齡、性別
    String name;
    int age;
    char gender;

    // 成員方法：吃飯、工作、休息
    public void eat() {
        System.out.println(name + " is eating.");
    }
    public void work() {
        System.out.println(name + " is working.");
    }
    public void rest() {
        System.out.println(name + " is resting.");
    }
}

定義了一個Person類，包含了姓名、年齡、性別這三個屬性和吃飯、工作、休息這三個方法，下面我們可以通過new關鍵字創建Person類的實例。

public static void main(String[] args) {
    // 創建Person類的實例
    Person person = new Person();
    // 調用成員變量和成員方法
    person.name = "Tom";
    person.age = 18;
    person.gender = 'M';
    person.eat();
    person.work();
    person.rest();
}

在這個例子中，我們通過new關鍵字創建了Person類的實例，隨後可以使用點號.來訪問實例的成員變量和成員方法。

二、構造方法和重載

構造方法是一種特殊的成員方法，用於創建對象時進行初始化，構造方法名與類名相同，沒有返回值類型。當我們創建一個對象時，會自動調用該對象的構造方法，如果我們沒有自定義構造方法，則會使用默認構造方法。

public class Person {
    // 成員變量：姓名、年齡、性別
    String name;
    int age;
    char gender;

    // 構造方法1
    public Person() {
        this.name = "Unknown";
        this.age = 0;
        this.gender = 'U';
    }

    // 構造方法2
    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    // 成員方法：吃飯、工作、休息
    public void eat() {
        System.out.println(name + " is eating.");
    }
    public void work() {
        System.out.println(name + " is working.");
    }
    public void rest() {
        System.out.println(name + " is resting.");
    }
}

在這個例子中，我們添加了兩個構造方法，可以根據不同的參數創建對象並初始化成員變量。另外，我們使用this關鍵字來區分成員變量和構造方法參數的同名屬性。

重載是指在同一個類中使用相同的方法名，但是參數列表不同的情況。Java允許我們對同一個方法進行重載，只要方法名相同，參數類型、個數或順序不同即可。

public int add(int a, int b) {
    return a + b;
}

public double add(double a, double b) {
    return a + b;
}

public String add(String a, String b) {
    return a + b;
}

在這個例子中，我們對add方法進行了重載，可以對int、double和String類型做不同的處理。

三、訪問修飾符和封裝

訪問修飾符是用於對類、屬性和方法進行訪問限制的關鍵字，Java中有四種訪問修飾符。

public：可以在任何地方被訪問

protected：可以被同一個包中的其他類訪問，或者子類繼承訪問

default：在同一個包中可以被訪問

private：只能被本類中的其他方法訪問，不能被其他類訪問

public class Person {
    // 成員變量：姓名、年齡、性別
    private String name;
    protected int age;
    char gender;

    // 構造方法1
    public Person() {
        this.name = "Unknown";
        this.age = 0;
        this.gender = 'U';
    }

    // 構造方法2
    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    // 成員方法：吃飯、工作、休息
    public void eat() {
        System.out.println(name + " is eating.");
    }
    protected void work() {
        System.out.println(name + " is working.");
    }
    void rest() {
        System.out.println(name + " is resting.");
    }

    // getter和setter方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

在這個例子中，我們使用private關鍵字來限制name屬性的訪問，使其只能在同一個類中訪問。同時，我們添加了getter和setter方法，用於對name屬性進行訪問和修改。

封裝是指隱藏對象的屬性和實現細節，只向外界提供訪問接口。封裝可以提高代碼的可重用性和安全性，對於複雜的對象系統尤其重要。

四、靜態變量和靜態方法

靜態變量和靜態方法屬於類本身，不屬於任何實例。使用static關鍵字來定義靜態變量和靜態方法。

public class Person {
    // 靜態變量：人的數量
    static int count = 0;
    // 成員變量：姓名、年齡、性別
    private String name;
    protected int age;
    char gender;

    // 構造方法1
    public Person() {
        this.name = "Unknown";
        this.age = 0;
        this.gender = 'U';
        count++;
    }

    // 構造方法2
    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        count++;
    }

    // 成員方法：吃飯、工作、休息
    public void eat() {
        System.out.println(name + " is eating.");
    }
    protected void work() {
        System.out.println(name + " is working.");
    }
    void rest() {
        System.out.println(name + " is resting.");
    }

    // 靜態方法：獲取人的數量
    public static int getCount() {
        return count;
    }
}

在這個例子中，我們添加了靜態變量count來表示Person類的實例數量，並在每個構造方法中進行了更新。同時，我們添加了靜態方法getCount來獲取實例數量。這些靜態變量和靜態方法可以通過類名.來訪問。

五、繼承和多態

繼承是指一個類可以繼承另一個類的屬性和方法，使得子類具有父類的共性和特徵。繼承可以減少代碼的重複，提高代碼的可維護性。

public class Student extends Person {
    // 成員變量：學號、班級
    String id;
    String clazz;

    // 構造方法1
    public Student() {
        super();
        this.id = "Unknown";
        this.clazz = "Unknown";
    }

    // 構造方法2
    public Student(String name, int age, char gender, String id, String clazz) {
        super(name, age, gender);
        this.id = id;
        this.clazz = clazz;
    }

    // 成員方法：上課、做作業
    public void attendClass() {
        System.out.println(name + " is attending class.");
    }
    public void doHomework() {
        System.out.println(name + " is doing homework.");
    }
}

在這個例子中，我們使用extends關鍵字來實現Student類對Person類的繼承，使得Student類自動擁有Person類的屬性和方法。子類可以使用super關鍵字來訪問父類的成員變量和成員方法。

多態是指同一個類的實例可以以不同的形態表現出不同的行為，即同樣的方法調用可能會有不同的實現效果。實現多態需要使用繼承、重寫和向上轉型等技術。

public static void display(Person person) {
    person.work();
}

Person person = new Person("Tom", 18, 'M');
Student student = new Student("Jerry", 20, 'M', "1234", "Class 1");
display(person); // Tom is working.
display(student); // Jerry is working.

在這個例子中，我們定義了一個靜態方法display，接受一個Person類型的參數，並調用work方法。當我們傳入一個Person實例或一個Student實例時，多態就會發生，實現不同的work行為。

六、總結

以上是對Java類與對象的介紹，包括類的定義和使用、構造方法和重載、訪問修飾符和封裝、靜態變量和靜態方法、繼承和多態等方面。類是Java語言的核心概念之一，理解和運用好類和對象的相關知識對於Java程序的開發至關重要。