interface OrderStrategy {
    void processOrder(Order order);
}
class NormalOrderStrategy implements OrderStrategy {
    @Override
    public void processOrder(Order order) {
        // 處理普通訂單
    }
}
class VIPOrderStrategy implements OrderStrategy {
    @Override
    public void processOrder(Order order) {
        // 處理VIP訂單
    }
}
// 在某個服務(wù)類中
class OrderService {
    private Map<String, OrderStrategy> strategies = new HashMap<>();
    public OrderService() {
        strategies.put("NORMAL", new NormalOrderStrategy());
        strategies.put("VIP", new VIPOrderStrategy());
    }
    public void processOrderByType(String type, Order order) {
        OrderStrategy strategy = strategies.getOrDefault(type, new DefaultOrderStrategy());
        strategy.processOrder(order);
    }
}

interface OrderState {
    void handle(OrderContext context);
}
class PendingState implements OrderState {
    @Override
    public void handle(OrderContext context) {
        // 處理待支付訂單
        context.setState(new PaidState()); // 假設(shè)支付后狀態(tài)改變
    }
}
class OrderContext {
    private OrderState state;
    public OrderContext() {
        this.state = new PendingState();
    }
    public void setState(OrderState state) {
        this.state = state;
    }
    public void handle() {
        state.handle(this);
    }
}

interface ProductFactory {
    Product createProduct(String type);
}
class ConcreteProductFactory implements ProductFactory {
    @Override
    public Product createProduct(String type) {
        if ("TypeA".equals(type)) {
            return new ProductA();
        } else if ("TypeB".equals(type)) {
            return new ProductB();
        }
        // 可以考慮拋出異?；蚍祷豱ull，但最好有默認(rèn)處理
        return new DefaultProduct();
    }
}
// 使用時
ProductFactory factory = new ConcreteProductFactory();
Product product = factory.createProduct("TypeA");

abstract class AbstractClass {
    // 模板方法
    final void templateMethod() {
        operation1();
        if (someCondition()) {
            operation2();
        }
        operation3();
    }
    // 抽象方法，由子類實現(xiàn)
    abstract void operation1();
    abstract void operation3();
    // 鉤子方法，子類可以選擇重寫
    boolean someCondition() {
        return true; // 默認(rèn)行為
    }
    void operation2() {
        // 默認(rèn)實現(xiàn)，子類可以選擇覆蓋
    }
}
class ConcreteClass extends AbstractClass {
    @Override
    void operation1() {
        // 實現(xiàn)
    }
    @Override
    void operation3() {
        // 實現(xiàn)
    }
    // 可以選擇重寫鉤子方法以改變條件行為
}
// 使用時
ConcreteClass concrete = new ConcreteClass();
concrete.templateMethod();