Spring Boot项目中遇到`if-else`语句七种具体使用方法解析

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订单
    }
}
// 在某个服务类中
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()); // 假设支付后状态改变
    }
}
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();
        }
        // 可以考虑抛出异常或返回null，但最好有默认处理
        return new DefaultProduct();
    }
}
// 使用时
ProductFactory factory = new ConcreteProductFactory();
Product product = factory.createProduct("TypeA");

abstract class AbstractClass {
    // 模板方法
    final void templateMethod() {
        operation1();
        if (someCondition()) {
            operation2();
        }
        operation3();
    }
    // 抽象方法，由子类实现
    abstract void operation1();
    abstract void operation3();
    // 钩子方法，子类可以选择重写
    boolean someCondition() {
        return true; // 默认行为
    }
    void operation2() {
        // 默认实现，子类可以选择覆盖
    }
}
class ConcreteClass extends AbstractClass {
    @Override
    void operation1() {
        // 实现
    }
    @Override
    void operation3() {
        // 实现
    }
    // 可以选择重写钩子方法以改变条件行为
}
// 使用时
ConcreteClass concrete = new ConcreteClass();
concrete.templateMethod();