在一個.java檔案裡面可以包含多個 class，但有以下幾個規則：

公開類別 (public class)：

1. 在一個檔案中，最多只能有一個 public 類別。如果有多個 public 類別，編譯會失敗。
2. 如果檔案中有一個 public 類別，那麼檔案名稱必須與這個 public 類別的名稱相同。例如:檔案中有一個 public class Main，那麼檔案名稱必須是 Main.java。

非公開類別 (non-public classes)：

1. 可以在同一個檔案中包含多個非公開類別（即沒有 public 修飾符的類別）。這些類別可以使用不同的名稱，且不必與檔案名稱相同。

Java的Class可以包含以下五個元素：

1. Fields（欄位）:相當於物件中的屬性。
2. Constructors（建構子）:類的建構方法，當創建新的類別物件(範例為Car)時會執行。
3. Methods（方法）:包括 getter 和 setter 方法，用來定義類的行為或功能。可以被多次調用，執行某些操作並可能返回值。
4. Blocks（區塊）:

• 實例初始化區塊：每次創建新物件時都會執行的代碼塊。
• 靜態區塊：在類加載時執行的代碼塊，用來初始化靜態欄位。

5. Nested class（內部類）以及 Interface（介面）:

• 內部類 Engine：可以訪問外部類的 brand 屬性，並且有一個方法 start()。
• 內部介面 Vehicle：定義一個 accelerate() 方法，並在外部類中通過 CarVehicle 類實現這個介面。

// Outer class
public class Car {

    // 1. Fields (欄位)
    private String brand;
    private int year;
    
    // Static field (靜態欄位)
    private static int carCount;

    // 2. Constructors (建構子)
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
        carCount++;
    }

    // 3. Methods (方法)
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public void drive() {
        System.out.println(brand + " is driving.");
    }

    // Static method (靜態方法)
    public static int getCarCount() {
        return carCount;
    }

    // 4. Blocks (區塊)

    // Instance initialization block (實例初始化區塊)
    {
        System.out.println("A new Car object is being created!");
    }

    // Static block (靜態區塊)
    static {
        carCount = 0; // 初始化靜態變量
        System.out.println("Static block: Car class loaded.");
    }

    // 5. Nested class and interface (內部類別和介面)

    // Nested class
    public class Engine {
        public void start() {
            System.out.println(brand + "'s engine is starting.");
        }
    }

    // Nested interface
    public interface Vehicle {
        void accelerate();
    }

    // Implementing the nested interface within the outer class
    public class CarVehicle implements Vehicle {
        @Override
        public void accelerate() {
            System.out.println(brand + " is accelerating.");
        }
    }
}

使用範例

public class Main {
    public static void main(String[] args) {
        // 創建 Car 物件
        Car myCar = new Car("Toyota", 2022);
        myCar.drive();  // 輸出: Toyota is driving.

        // 使用內部類 Engine
        Car.Engine engine = myCar.new Engine();
        engine.start();  // 輸出: Toyota's engine is starting.

        // 使用內部介面的實現
        Car.CarVehicle vehicle = myCar.new CarVehicle();
        vehicle.accelerate();  // 輸出: Toyota is accelerating.

        // 獲取 Car 物件的總數
        System.out.println("Total cars: " + Car.getCarCount());
    }
}