Java 設計模式是用于解決軟件設計問題的經典解決方案。它們提供了一種可重用的方法，以應對不斷變化的需求和問題。以下是幾種常見的 Java 設計模式，可以幫助應對變化：

1. 策略模式（Strategy Pattern）：策略模式允許你定義一系列算法，并將它們封裝在一個對象中，使得它們可以相互替換。這樣，算法的變化不會影響到使用算法的客戶端代碼。策略模式通過定義一個接口來封裝算法，然后提供不同的實現類來表示不同的算法。這使得算法可以在不改變客戶端代碼的情況下進行更改。

// 策略接口
public interface Strategy {
    int doOperation(int a, int b);
}

// 具體策略類
public class AddStrategy implements Strategy {
    @Override
    public int doOperation(int a, int b) {
        return a + b;
    }
}

// 客戶端代碼
public class Client {
    public static void main(String[] args) {
        Strategy strategy = new AddStrategy();
        int result = strategy.doOperation(1, 2);
        System.out.println("Result: " + result);
    }
}

2. 觀察者模式（Observer Pattern）：觀察者模式定義了一種一對多的依賴關系，當一個對象（被觀察者）的狀態發生改變時，所有依賴于它的對象（觀察者）都會得到通知并自動更新。這種模式使得我們可以在不修改被觀察者代碼的情況下，輕松地添加新的觀察者。

// 主題接口
public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具體主題類
public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }

    public void changeState() {
        notifyObservers();
    }
}

// 觀察者接口
public interface Observer {
    void update();
}

// 具體觀察者類
public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update() {
        System.out.println(name + " has been notified.");
    }
}

// 客戶端代碼
public class Client {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        subject.changeState();
    }
}

3. 模板方法模式（Template Method Pattern）：模板方法模式定義了一個算法的骨架，而將一些步驟的實現延遲到子類中。這樣，我們可以在不改變算法結構的情況下，通過重寫子類中的方法來應對需求的變化。

// 抽象類
public abstract class AbstractTemplateMethod {
    public final void templateMethod() {
        step1();
        step2();
        step3();
    }

    protected abstract void step1();

    protected abstract void step2();

    protected void step3() {
        System.out.println("Step 3");
    }
}

// 具體子類
public class ConcreteTemplateMethod extends AbstractTemplateMethod {
    @Override
    protected void step1() {
        System.out.println("ConcreteTemplateMethod step 1");
    }

    @Override
    protected void step2() {
        System.out.println("ConcreteTemplateMethod step 2");
    }
}

// 客戶端代碼
public class Client {
    public static void main(String[] args) {
        AbstractTemplateMethod templateMethod = new ConcreteTemplateMethod();
        templateMethod.templateMethod();
    }
}

通過使用這些設計模式，我們可以更好地應對 Java 項目中的變化，提高代碼的可維護性和可擴展性。