设计原则¶

// ❌ 飞行行为直接写在基类，RubberDuck 被迫继承并覆盖为空
public abstract class Duck {
    public void fly() {
        System.out.println("我在飞！"); // ← 变化点混在稳定行为里
    }
    public abstract void display();
}

public class RubberDuck extends Duck {
    @Override
    public void fly() { /* 橡皮鸭不会飞，什么都不做 */ } // ❌ 被迫的空实现
}

// ✅ 把"飞行行为"（变化点）提取为独立接口
public interface FlyBehavior {
    void fly();
}

public class FlyWithWings implements FlyBehavior {
    @Override public void fly() { System.out.println("我在用翅膀飞！"); }
}

public class FlyNoWay implements FlyBehavior {
    @Override public void fly() { System.out.println("我飞不起来"); } // 橡皮鸭用此
}

// Duck 的稳定部分（游泳、display）不受飞行变化影响
public abstract class Duck {
    private FlyBehavior flyBehavior; // HAS-A 持有行为

    public void performFly() { flyBehavior.fly(); }
    public abstract void display();
}

// ❌ Dog 直接 new 了一个 Animal 的具体子类 — 鸭子嗯
Dog d = new Dog();
d.bark(); // 调用方与 Dog 这个具体类绑定

// ✅ 变量声明为接口类型，具体实现从外部注入
Animal animal = new Dog();     // 可以换成 Cat、Duck...
animal.makeSound();            // 调用接口方法，不知道也不关心具体是什么

// ✅ Duck 只知道 FlyBehavior 接口，不关心具体是哪种飞法
public abstract class Duck {
    FlyBehavior flyBehavior;   // ← 变量类型是接口，不是 FlyWithWings

    public void setFlyBehavior(FlyBehavior fb) {
        this.flyBehavior = fb; // 运行时可以更换飞行行为
    }
}

// ❌ WeatherData 直接调用显示板的具体方法
public class WeatherData {
    private CurrentConditionsDisplay currentDisplay;
    private StatisticsDisplay statisticsDisplay;

    public void measurementsChanged() {
        // 直接调用具体显示板 — 添加新显示板必须修改这里 ❌
        currentDisplay.update(temperature, humidity, pressure);
        statisticsDisplay.update(temperature, humidity, pressure);
    }
}

// ✅ Subject 和 Observer 只通过接口彼此认识
public interface Observer {
    void update(float temp, float humidity, float pressure);
}

public class WeatherData implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void notifyObservers() {
        for (Observer o : observers) {
            o.update(temperature, humidity, pressure); // 只知道 Observer 接口
        }
    }
}

// 三个变化维度各自独立为接口
public interface Engine {
    void run();
}

public interface DriveControl {
    void control();
}

// 具体实现：电动 / 汽油
public class ElectricEngine implements Engine { ... }
public class CombustionEngine implements Engine { ... }

// 具体实现：手动 / 自动驾驶
public class ManualControl  implements DriveControl { ... }
public class AutopilotControl implements DriveControl { ... }

// 车辆通过组合持有各维度的实现
public class Car {
    private Engine engine;           // 可以是 ElectricEngine 或 CombustionEngine
    private DriveControl control;    // 可以是 ManualControl 或 AutopilotControl

    public Car(Engine engine, DriveControl control) {
        this.engine = engine;
        this.control = control;
    }
}

// 使用时按需组合，无需预先创建所有组合子类
Car electricAutoCar = new Car(new ElectricEngine(), new AutopilotControl());
Car gasManualTruck = new Car(new CombustionEngine(), new ManualControl());

// ❌ User 类承担了三件事：数据存储、发邮件、写日志
public class User {
    private String name;
    private String email;

    // 职责一：业务数据
    public void setName(String name) { this.name = name; }

    // 职责二：发邮件（和用户数据无关）
    public void sendWelcomeEmail() {
        // 调用邮件服务...
    }

    // 职责三：记录日志（和用户数据无关）
    public void logUserCreation() {
        // 写日志文件...
    }
}

// ✅ 职责拆分后，每个类只做一件事
public class User {
    private String name;
    private String email;
    // 只管数据
}

public class EmailService {
    public void sendWelcomeEmail(User user) {
        // 只管发邮件
    }
}

public class UserLogger {
    public void logCreation(User user) {
        // 只管日志
    }
}

// ❌ 每次新增折扣类型，都要修改这个方法
public class OrderService {
    public double calculateDiscount(Order order, String discountType) {
        if ("VIP".equals(discountType)) {
            return order.getAmount() * 0.8;
        } else if ("STUDENT".equals(discountType)) {
            return order.getAmount() * 0.9;
        } else if ("EMPLOYEE".equals(discountType)) { // ← 新增时要改这里
            return order.getAmount() * 0.7;
        }
        return order.getAmount();
    }
}

// ✅ 定义折扣策略接口，新增折扣类型只需新增实现类，无需改已有代码
public interface DiscountStrategy {
    double calculate(double amount);
}

public class VipDiscount implements DiscountStrategy {
    @Override
    public double calculate(double amount) {
        return amount * 0.8; // VIP 八折
    }
}

public class StudentDiscount implements DiscountStrategy {
    @Override
    public double calculate(double amount) {
        return amount * 0.9; // 学生九折
    }
}

// 新增员工折扣：只需加这个类，其他代码不动
public class EmployeeDiscount implements DiscountStrategy {
    @Override
    public double calculate(double amount) {
        return amount * 0.7; // 员工七折
    }
}

// ❌ 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 area() { 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;
    }
}

// 调用方按矩形理解使用，结果出错
void useRectangle(Rectangle r) {
    r.setWidth(5);
    r.setHeight(3);
    System.out.println(r.area()); // 期望 15，但 Square 输出 9！ ❌
}

// ✅ Rectangle 和 Square 各自独立，不存在继承关系
public interface Shape {
    int area();
}

public class Rectangle implements Shape { ... }
public class Square    implements Shape { ... }

// ❌ 胖接口：Dog 被迫实现 fly()
public interface Animal {
    void eat();
    void fly();   // 狗不会飞！
    void swim();
}

public class Dog implements Animal {
    @Override public void eat()  { System.out.println("吃饭"); }
    @Override public void fly()  { throw new UnsupportedOperationException("狗不会飞"); } // ❌ 被迫的空实现
    @Override public void swim() { System.out.println("游泳"); }
}

// ✅ 细粒度接口：按行为能力拆分
public interface Eatable  { void eat(); }
public interface Flyable  { void fly(); }
public interface Swimmable { void swim(); }

// Dog 只实现它能做到的
public class Dog implements Eatable, Swimmable {
    @Override public void eat()  { System.out.println("吃饭"); }
    @Override public void swim() { System.out.println("游泳"); }
}

// Bird 实现飞行和进食
public class Bird implements Eatable, Flyable {
    @Override public void eat() { System.out.println("啄食"); }
    @Override public void fly() { System.out.println("飞翔"); }
}

// ❌ 高层模块直接依赖低层具体类
public class UserService {
    private MySQLUserRepository repository; // ← 直接依赖 MySQL 实现

    public UserService() {
        this.repository = new MySQLUserRepository(); // ← 硬编码创建
    }
}
// 想换成 MongoDB？UserService 必须修改——这正是耦合的危害

// ✅ 依赖抽象接口，具体实现通过构造函数注入
public interface UserRepository {
    User findById(Long id);
    void save(User user);
}

public class MySQLUserRepository implements UserRepository { /* MySQL 实现 */ }
public class MongoUserRepository  implements UserRepository { /* MongoDB 实现 */ }

// UserService 只知道 UserRepository 接口，不关心具体实现
public class UserService {
    private final UserRepository repository;

    // 通过构造函数注入（Spring 的 @Autowired 就是这个原理）
    public UserService(UserRepository repository) {
        this.repository = repository;
    }

    public User findById(Long id) {
        return repository.findById(id);
    }
}

// ❌ 两处都写了相同的邮箱校验逻辑
public class UserController {
    public void register(String email) {
        if (!email.contains("@") || email.length() < 5) { // ← 重复
            throw new IllegalArgumentException("邮箱格式不正确");
        }
    }
}

public class AdminController {
    public void addAdmin(String email) {
        if (!email.contains("@") || email.length() < 5) { // ← 重复
            throw new IllegalArgumentException("邮箱格式不正确");
        }
    }
}

// ✅ 提取为公共工具类，只有一处权威逻辑
public class EmailValidator {
    public static boolean isValid(String email) {
        return email.contains("@") && email.length() >= 5;
    }
}

// isValidUsername 和 isValidPassword 实现完全一样，但语义不同
// ✅ 不应该合并！因为两者将来会独立演变（密码允许大写、更长长度...）
private boolean isValidUsername(String username) {
    if (StringUtils.isBlank(username)) return false;
    int length = username.length();
    if (length < 4 || length > 64) return false;
    if (!StringUtils.isAllLowerCase(username)) return false;
    return true;
}

private boolean isValidPassword(String password) {
    if (StringUtils.isBlank(password)) return false; // ← 当前实现一样
    int length = password.length();
    if (length < 4 || length > 64) return false;    // ← 但密码规则未来会不同
    if (!StringUtils.isAllLowerCase(password)) return false;
    return true;
}

// ❌ 两个方法功能完全一样，都在校验 IP 合法性，却有两份实现
public boolean isValidIp(String ipAddress) {
    // ... 用正则实现
}

public boolean checkIfIpValid(String ipAddress) {
    // ... 用字符串分割实现
}
// 问题：校验规则变化时，只更新了一处，另一处变成了 bug

// ❌ 行数最少，但正则本身难以阅读和维护
public boolean isValidIpV1(String ipAddress) {
    if (StringUtils.isBlank(ipAddress)) return false;
    String regex = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
        + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
        + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
        + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$";
    return ipAddress.matches(regex);
}

// ✅ 逻辑清晰，借助标准工具类，团队中大多数人都能读懂
public boolean isValidIpV2(String ipAddress) {
    if (StringUtils.isBlank(ipAddress)) return false;
    String[] parts = StringUtils.split(ipAddress, '.');
    if (parts.length != 4) return false;
    for (int i = 0; i < 4; i++) {
        int val = Integer.parseInt(parts[i]); // 非法格式会抛异常
        if (val < 0 || val > 255) return false;
        if (i == 0 && val == 0) return false;
    }
    return true;
}

// ⚠️ 除非是性能瓶颈，否则这种底层优化增加了不必要的复杂度
public boolean isValidIpV3(String ipAddress) {
    char[] chars = ipAddress.toCharArray();
    // ... 逐字符手动解析（约 30 行）
}

// ❌ 深层链式调用，需要了解 Order → Customer → Address → City 的内部结构
public class OrderService {
    public String getCityName(Order order) {
        return order.getCustomer().getAddress().getCity().getName();
    }
}

// ✅ 通过封装隐藏内部结构，OrderService 只和 Order 这一个"朋友"交互
public class Order {
    public String getCustomerCityName() {
        return customer.getCityName(); // 代理给直接朋友 Customer
    }
}

public class Customer {
    public String getCityName() {
        return address.getCityName(); // 代理给直接朋友 Address
    }
}

// ❌ Document 的职责是表示网页内容，它不应该关心"怎么下载网页"
public class Document {
    private Html html;
    public Document(String url) {
        HtmlDownloader downloader = new HtmlDownloader(); // ← 越界了
        this.html = downloader.downloadHtml(url);
    }
}

// ✅ 下载逻辑由调用方负责，Document 只负责持有和处理 Html 内容
public class Document {
    private Html html;
    public Document(Html html) {
        this.html = html; // ← 直接依赖传入，不关心怎么来的
    }
}

// ❌ 用继承复用日志功能：与 LoggableService 强绑定
public class LoggableService {
    protected void log(String msg) { System.out.println("[LOG] " + msg); }
}

public class UserService extends LoggableService {
    public void createUser() {
        log("创建用户");
    }
}

// ✅ Logger 作为成员变量注入，耦合度更低
public class Logger {
    public void log(String msg) { System.out.println("[LOG] " + msg); }
}

public class UserService {
    private final Logger logger;

    public UserService(Logger logger) { this.logger = logger; }

    public void createUser() {
        logger.log("创建用户");
    }
}

// ❌ 子类主动调用父类方法，控制权在子类
public class Tea {
    void prepareRecipe() {
        boilWater();        // 自己调用父类方法
        steepTeaBag();
        pourInCup();
        addLemon();
    }
    void boilWater()    { System.out.println("煮水"); }
    void pourInCup()    { System.out.println("倒入杯中"); }
    void steepTeaBag()  { System.out.println("浸泡茶包"); }
    void addLemon()     { System.out.println("加柠檬"); }
}

// ✅ 父类（高层组件）掌控算法骨架，子类（低层组件）只提供具体实现
public abstract class CaffeineBeverage {
    // 模板方法 — 父类调用子类，子类不调用父类
    final void prepareRecipe() {
        boilWater();
        brew();          // ← 父类在适当时机"调用"子类
        pourInCup();
        addCondiments(); // ← 父类决定是否调用子类的钩子
    }

    abstract void brew();
    abstract void addCondiments();

    private void boilWater() { System.out.println("煮水"); }
    private void pourInCup() { System.out.println("倒入杯中"); }
}

public class Tea extends CaffeineBeverage {
    @Override void brew()          { System.out.println("浸泡茶包"); }
    @Override void addCondiments() { System.out.println("加柠檬"); }
    // 子类只提供具体实现，不主动控制流程 ✅
}