策略设计模式

策略模式定义:

定义一组算法，将每个算法都封装起来，并且使它们之间可以互换

使用场景

1. 多个类只有在算法或行为上稍有不同的场景

2. 算法需要自由切换的场景

3. 需要屏蔽算法规则的场景

角色定义

Context 封装角色

它也叫做上下文角色，起承上启下封装作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。

Strategy 抽象策略角色

策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性

ConcreteStrategy 具体策略角色

实现抽象策略中的操作，该类含有具体的算法

需求背景

实现一个计算器，具有加减乘除的功能

1. 首先，我们定义一个接口，表示计算器中的各种运算：（Context）

public interface Operation {
    double doOperation(double num1, double num2);
}

2. 然后，我们实现加法、减法、乘法和除法四种运算的具体实现：(Strategy)

public class AddOperation implements Operation {
    @Override
    public double doOperation(double num1, double num2) {
        return num1 + num2;
    }
}

public class SubOperation implements Operation {
    @Override
    public double doOperation(double num1, double num2) {
        return num1 - num2;
    }
}

public class MulOperation implements Operation {
    @Override
    public double doOperation(double num1, double num2) {
        return num1 * num2;
    }
}

public class DivOperation implements Operation {
    @Override
    public double doOperation(double num1, double num2) {
        if (num2 == 0) {
            throw new IllegalArgumentException("除数不能为零");
        }
        return num1 / num2;
    }
}

3. 接下来，我们定义一个计算器类，该类接收两个数字和一个运算接口，根据传入的运算接口来执行相应的运算：(ConcreteStrategy)

public class Calculator {
    private Operation operation;

    public Calculator(Operation operation) {
        this.operation = operation;
    }

    public double calculate(double num1, double num2) {
        return operation.doOperation(num1, num2);
    }
}

4. 最后，我们编写一个测试类，测试不同的运算：

public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calculator = new Calculator(new AddOperation());
        double result = calculator.calculate(1, 2);
        assertEquals(3, result, 0.001);
    }

    @Test
    public void testSub() {
        Calculator calculator = new Calculator(new SubOperation());
        double result = calculator.calculate(3, 2);
        assertEquals(1, result, 0.001);
    }

    @Test
    public void testMul() {
        Calculator calculator = new Calculator(new MulOperation());
        double result = calculator.calculate(2, 3);
        assertEquals(6, result, 0.001);
    }

    @Test
    public void testDiv() {
        Calculator calculator = new Calculator(new DivOperation());
        double result = calculator.calculate(6, 3);
        assertEquals(2, result, 0.001);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDivByZero() {
        Calculator calculator = new Calculator(new DivOperation());
        calculator.calculate(6, 0);
    }
}

5. 小结

策略模式是一种常用的设计模式，它可以帮助我们实现代码的高内聚、低耦合，提高代码的可扩展性、可维护性和可复用性。在实际开发中，我们可以根据不同的需求，选择不同的策略实现，从而满足不同的业务需求。