《设计模式》18.策略模式（行为型）_策略模式 public void arithmetic-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_37477523/article/details/90239292

本文深入探讨了策略模式的设计原则，通过实例展示了如何使用策略模式封装算法，使其可以在运行时互换，从而提高代码的灵活性和可维护性。文章详细介绍了抽象策略、具体策略和上下文角色，并提供了四则运算的具体实现案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义一系列的算法，将每一个算法封装起来，使算法的行为和实现分离开，算法可以相互替换并不影响用户

角色

抽象策略（Strategy）：定义一个策略接口
具体策略（Concrete Strategy）：抽象策略实现，不同的策略提供不同的实现方式
上下文（Context）：持有策略类的引用，对外提供 setStrategy 方法和执行策略接口的方法供用户调用

抽象策略 Strategy

public interface Strategy {
    void operate();
}

具体策略 Concrete Strategy

public class ConcreteStrategy implements Strategy {
    @Override
    public void operate() {
        System.out.println("execute strategy calculate...");
    }
}

上下文 Context

public class Context {
    private Strategy strategy;

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

    public void execute() {
        strategy.operate();
    }
}

测试类

public class StrategyPattern {
    public static void main(String args[]) {
        Context context = new Context();
        context.setStrategy(new ConcreteStrategy());
        context.execute();
    }
}

execute strategy calculate...

举例：四则运算

public interface Operation {
    int calculate(int optNum1, int optNum2);
}

public class Add implements Operation {
    @Override
    public int calculate(int optNum1, int optNum2) {
        int result = optNum1 + optNum2;
        System.out.println(String.format("%d + %d = %d", optNum1, optNum2, result));
        return result;
    }
}

public class Divide implements Operation {
    @Override
    public int calculate(int optNum1, int optNum2) {
        int result = optNum1 / optNum2;
        System.out.println(String.format("%d / %d = %d", optNum1, optNum2, result));
        return result;
    }
}

public class Multiply implements Operation {
    @Override
    public int calculate(int optNum1, int optNum2) {
        int result = optNum1 * optNum2;
        System.out.println(String.format("%d * %d = %d", optNum1, optNum2, result));
        return result;
    }
}

public class Subtract implements Operation {
    @Override
    public int calculate(int optNum1, int optNum2) {
        int result = optNum1 - optNum2;
        System.out.println(String.format("%d - %d = %d", optNum1, optNum2, result));
        return result;
    }
}

public class Arithmetic {
    private Operation operation;
    public void setOperation(Operation operation) {
        this.operation = operation;
    }

    public int getResult(int optNum1, int optNum2) {
        return operation.calculate(optNum1, optNum2);
    }
}

public class StrategyPattern {
    public static void main(String args[]) {
        Arithmetic arithmetic = new Arithmetic();

        //add
        arithmetic.setOperation(new Add());
        arithmetic.getResult(2, 3);

        //subtract
        arithmetic.setOperation(new Subtract());
        arithmetic.getResult(9, 3);

        //multiply
        arithmetic.setOperation(new Multiply());
        arithmetic.getResult(3, 5);

        //divide
        arithmetic.setOperation(new Divide());
        arithmetic.getResult(8, 4);
    }
}