单一职责原则（设计模式）

// 定义通用策略接口
public interface UserOperationStrategy {
    void execute(User user);
}

// 修改策略
public class ModifyUserStrategy implements UserOperationStrategy {
    @Override
    public void execute(User user) {
        System.out.println("修改用户信息: " + user.getName());
    }
}

// 添加策略
public class AddUserStrategy implements UserOperationStrategy {
    @Override
    public void execute(User user) {
        System.out.println("添加新用户: " + user.getName());
    }
}

// 上下文类，动态选择操作
public class UserService {
    private UserOperationStrategy strategy;

    public void setStrategy(UserOperationStrategy strategy) {
        this.strategy = strategy;
    }

    public void executeOperation(User user) {
        strategy.execute(user);
    }
}

// 使用策略
public class Main {
    public static void main(String[] args) {
        User user = new User("Tom");

        UserService userService = new UserService();

        // 进行添加操作
        userService.setStrategy(new AddUserStrategy());
        userService.executeOperation(user);

        // 进行修改操作
        userService.setStrategy(new ModifyUserStrategy());
        userService.executeOperation(user);
    }
}

优点：

让"修改"和"添加"逻辑完全解耦，互不影响。
方便扩展，比如再加一个"删除用户"策略。

方式 2：使用装饰者模式

如果修改和添加可以叠加，可以使用装饰者模式，在原功能基础上动态增加额外行为，而不改变原类的代码。

示例：用户操作

java 复制代码

// 定义基础接口
public interface UserOperation {
    void execute();
}

// 基础实现（原始功能）
public class BaseUserOperation implements UserOperation {
    @Override
    public void execute() {
        System.out.println("基础用户操作");
    }
}

// 装饰器基类
public abstract class UserOperationDecorator implements UserOperation {
    protected UserOperation decoratedOperation;

    public UserOperationDecorator(UserOperation decoratedOperation) {
        this.decoratedOperation = decoratedOperation;
    }

    @Override
    public void execute() {
        decoratedOperation.execute();
    }
}

// 添加用户功能
public class AddUserDecorator extends UserOperationDecorator {
    public AddUserDecorator(UserOperation decoratedOperation) {
        super(decoratedOperation);
    }

    @Override
    public void execute() {
        super.execute();
        System.out.println("添加用户");
    }
}

// 修改用户功能
public class ModifyUserDecorator extends UserOperationDecorator {
    public ModifyUserDecorator(UserOperation decoratedOperation) {
        super(decoratedOperation);
    }

    @Override
    public void execute() {
        super.execute();
        System.out.println("修改用户");
    }
}

// 使用装饰器
public class Main {
    public static void main(String[] args) {
        UserOperation operation = new BaseUserOperation();
        
        // 先添加，再修改
        UserOperation addThenModify = new ModifyUserDecorator(new AddUserDecorator(operation));
        addThenModify.execute();
    }
}

输出

基础用户操作
添加用户
修改用户

优点

动态组合行为，比如 先添加再修改 或者 只修改不添加。
方便扩展，不用修改原类。

方式 3：使用责任链模式

如果修改和添加是流程中的不同步骤，可以用责任链模式，让不同操作按顺序执行，方便扩展。

示例：用户操作链

javascript 复制代码

// 责任链接口
public interface UserHandler {
    void handle(User user);
}

// 责任链基类
public abstract class AbstractUserHandler implements UserHandler {
    protected UserHandler nextHandler;

    public void setNextHandler(UserHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handle(User user) {
        if (nextHandler != null) {
            nextHandler.handle(user);
        }
    }
}

// 添加用户处理器
public class AddUserHandler extends AbstractUserHandler {
    @Override
    public void handle(User user) {
        System.out.println("添加用户: " + user.getName());
        super.handle(user);
    }
}

// 修改用户处理器
public class ModifyUserHandler extends AbstractUserHandler {
    @Override
    public void handle(User user) {
        System.out.println("修改用户信息: " + user.getName());
        super.handle(user);
    }
}

// 流程控制
public class Main {
    public static void main(String[] args) {
        User user = new User("Tom");

        // 责任链
        AddUserHandler addHandler = new AddUserHandler();
        ModifyUserHandler modifyHandler = new ModifyUserHandler();

        addHandler.setNextHandler(modifyHandler);

        // 先添加，再修改
        addHandler.handle(user);
    }
}

输出

添加用户: Tom
修改用户信息: Tom

总结

方案	适用场景	主要特点
策略模式	修改和添加是两种独立操作	通过不同策略切换操作，逻辑清晰，便于扩展
装饰者模式	需要叠加功能，比如先添加再修改	允许动态组合多个操作，避免修改原类
责任链模式	操作有固定顺序，比如先添加再修改	让多个处理器按顺序执行，扩展性强

单一职责原则（设计模式）

问题：

定义：

解决：

方式 1：使用策略模式

示例：用户管理

方式 2：使用装饰者模式

示例：用户操作

方式 3：使用责任链模式

示例：用户操作链

总结

推荐