Java 设计原则详解

// ❌ 违反 OCP：每次新增支付方式都要修改代码
public class PaymentProcessor {
    public void process(String type, double amount) {
        if (type.equals("ALIPAY")) {
            // 支付宝支付逻辑
        } else if (type.equals("WECHAT")) {
            // 微信支付逻辑
        }
        // 新增支付方式需要修改此处
    }
}

// ✅ 符合 OCP：通过扩展添加新支付方式
public interface PaymentStrategy {
    void pay(double amount);
    boolean supports(String paymentType);
}

@Component
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("支付宝支付: " + amount);
    }
    
    @Override
    public boolean supports(String type) {
        return "ALIPAY".equals(type);
    }
}

@Component
public class WechatStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("微信支付: " + amount);
    }
    
    @Override
    public boolean supports(String type) {
        return "WECHAT".equals(type);
    }
}

@Service
public class PaymentService {
    private final List<PaymentStrategy> strategies;
    
    public PaymentService(List<PaymentStrategy> strategies) {
        this.strategies = strategies;
    }
    
    public void processPayment(String type, double amount) {
        PaymentStrategy strategy = strategies.stream()
            .filter(s -> s.supports(type))
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("不支持的支付方式"));
        strategy.pay(amount);
    }
}

// ❌ 违反 LSP：Square 改变了 Rectangle 的行为
public class Rectangle {
    protected int width;
    protected int height;
    
    public void setWidth(int width) { this.width = width; }
    public void setHeight(int height) { this.height = height; }
    public int getArea() { return width * height; }
}

public class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width; // 破坏父类行为
    }
    
    @Override
    public void setHeight(int height) {
        this.width = height;
        this.height = height;
    }
}

// 测试时会出现问题
public void testRectangle(Rectangle rect) {
    rect.setWidth(5);
    rect.setHeight(4);
    assert rect.getArea() == 20; // Square 会失败
}

// ✅ 符合 LSP：正确的继承设计
public interface Shape {
    int getArea();
}

public class Rectangle implements Shape {
    private int width;
    private int height;
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public int getArea() {
        return width * height;
    }
}

public class Square implements Shape {
    private int side;
    
    public Square(int side) {
        this.side = side;
    }
    
    @Override
    public int getArea() {
        return side * side;
    }
}

// ❌ 违反 DIP：高层模块依赖具体实现
public class UserService {
    // 直接依赖具体实现
    private MySQLUserRepository repository = new MySQLUserRepository();
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

// ✅ 符合 DIP：依赖抽象
public interface UserRepository {
    User findById(Long id);
    void save(User user);
}

@Repository
public class MySQLUserRepository implements UserRepository {
    @Override
    public User findById(Long id) { }
    
    @Override
    public void save(User user) { }
}

@Service
public class UserService {
    private final UserRepository userRepository;
    
    // 通过构造器注入依赖
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUser(Long id) {
        return userRepository.findById(id);
    }
}

// 测试时可以轻松替换实现
public class InMemoryUserRepository implements UserRepository {
    private Map<Long, User> users = new HashMap<>();
    
    @Override
    public User findById(Long id) {
        return users.get(id);
    }
    
    @Override
    public void save(User user) {
        users.put(user.getId(), user);
    }
}