Java入門-Day8：物件導向

類別（Class）

建構子（Constructor）

在Java中，建構子是一種特殊類型的方法，用於初始化類別的新物件。它的名稱與類別名稱相同，並且沒有返回類型。常見的用法包括初始化實例變數或執行必要的設置。

public class Car {
    private String brand;
    private String model;

    // 建構子
    public Car(String brand, String model) {
        this.brand = brand;
        this.model = model;
    }

    public void displayInfo() {
        System.out.println("Brand: " + brand + ", Model: " + model);
    }

    public static void main(String[] args) {
        // 使用建構子創建物件
        Car myCar = new Car("Toyota", "Camry");
        myCar.displayInfo();
    }
}

公開（Public）、私有（Private）、受保護（Protected）

這些是Java中用於訪問控制的關鍵字：

• public: 可以被任何其他類別訪問。
• private: 只能在定義它們的類別內部訪問。
• protected: 只能在相同的包或子類別中訪問。

public class Example {
    public String publicField;
    private String privateField;
    protected String protectedField;
}

繼承（Inheritance）

繼承允許一個類別（子類別）從另一個類別（父類別）繼承屬性和方法。子類別可以擴展和重用父類別的功能。

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

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

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound(); // Output: Dog barks
    }
}

多型（Polymorphism）

多型是指通過繼承和覆蓋方法來實現同一操作具有多種不同形式的能力。

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

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

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

    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.sound(); // Output: Dog barks

        myAnimal = new Cat();
        myAnimal.sound(); // Output: Cat meows
    }
}

封裝（Encapsulation）

封裝是一種將數據（變數）和方法（函數）包裝在一起的機制，並限制對其訪問的外部訪問。它通常通過設置變數的訪問修飾符來實現。

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

    // 封裝的方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

介面（Interface）

介面定義了一組方法的規範，但不提供方法的實現。類別可以實現一個或多個介面，並實現其定義的方法。

// 介面
public interface Vehicle {
    void start();
    void stop();
}

// 實現介面
public class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Car started");
    }

    @Override
    public void stop() {
        System.out.println("Car stopped");
    }
}

抽象類別（Abstract Class）

抽象類別是不能被實例化的類別，它可以包含抽象方法（只有方法聲明，沒有方法體）和具體方法實現。子類別必須實現（覆蓋）抽象方法。

// 抽象類別
public abstract class Shape {
    abstract void draw();
}

// 實現抽象類別
public class Rectangle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a rectangle");
    }
}

靜態類別（Static Class）

靜態類別是一個被static修飾的內部類別，它可以直接訪問外部類別的靜態成員和方法，而無需實例化外部類別。

public class OuterClass {
    private static String message = "Hello, Static Class!";

    // 靜態內部類別
    static class StaticNestedClass {
        void displayMessage() {
            System.out.println(message);
        }
    }

    public static void main(String[] args) {
        OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
        nestedObject.displayMessage(); // Output: Hello, Static Class!
    }
}

列舉（Enumerations）

列舉是一種特殊類型的類別，它表示一組命名的常量。列舉類型可以包含屬性、方法和構造函數。

public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

public class EnumExample {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("Today is " + today);
    }
}

Lambda 表達式

Lambda 表達式是一種輕量級的匿名函數，它允許直接傳遞函數作為參數給方法或創建簡單的函數。

public class LambdaExample {
    public static void main(String[] args) {
        // Lambda 表達式作為參數
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread running: " + i);
            }
        });

        thread.start();
    }
}

泛型（Generics）

泛型允許類別或方法在定義時指定一種或多種類型參數，提高了代碼的重用性和類型安全性。

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello, Generics!");

        String content = stringBox.getContent();
        System.out.println(content);
    }
}

反射（Reflection）

反射是Java提供的一種機制，用於在運行時檢查或修改類別、方法、屬性等的信息，並動態調用方法。

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        // 獲取類別
        Class<?> clazz = Class.forName("java.lang.String");

        // 獲取方法
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName());
        }
    }
}