策略模式：简单实现，却蕴藏着复杂设计

前端

2023-08-28 13:39:34

策略模式：分离算法，拥抱灵活性

理解策略模式的本质

策略模式是一种广受欢迎的设计模式，它允许你分离算法的实现与使用算法的代码。这提供了一种优雅且灵活的方式来改变程序的行为，而无需修改其核心结构。

然而，对于策略模式的误解和滥用非常普遍，导致它在实践中经常产生问题。以下是一些常见的问题：

缺乏深刻理解： 许多开发者将策略模式视为一种简单的if-else语句封装，而忽略了它本质上旨在分离算法与应用场景的关键目的。
盲目套用框架： 许多教程和设计模式提供固定的框架，导致开发者机械地套用这些框架，而没有考虑实际场景和需求的差异性。
缺乏设计经验： 策略模式的应用涉及到多个类之间的协作和交互，需要开发者具备一定的代码结构和组织能力。

正确设计策略模式

为了正确设计策略模式，遵循以下基本原则至关重要：

定义算法和应用场景： 明确需要分离的算法和应用场景，确保它们之间具有明确的界限和独立性。
创建抽象接口： 定义算法的公共行为和接口，该接口应该包含所有算法都需要实现的方法和属性。
实现具体算法： 创建多个具体的算法类，每个类都实现抽象接口中定义的方法和属性。
引入策略上下文： 管理和使用具体算法，策略上下文类负责将抽象接口与具体的算法类关联起来，并在需要时动态选择和执行算法。

代码示例

以下是一个使用策略模式实现简单计算器的代码示例：

// 抽象接口
interface ICalculator {
    double add(double a, double b);
    double subtract(double a, double b);
    double multiply(double a, double b);
    double divide(double a, double b);
}

// 具体算法类
class AdditionCalculator implements ICalculator {
    @Override
    public double add(double a, double b) {
        return a + b;
    }

    @Override
    public double subtract(double a, double b) {
        throw new UnsupportedOperationException("AdditionCalculator does not support subtraction.");
    }

    @Override
    public double multiply(double a, double b) {
        throw new UnsupportedOperationException("AdditionCalculator does not support multiplication.");
    }

    @Override
    public double divide(double a, double b) {
        throw new UnsupportedOperationException("AdditionCalculator does not support division.");
    }
}

class SubtractionCalculator implements ICalculator {
    @Override
    public double add(double a, double b) {
        throw new UnsupportedOperationException("SubtractionCalculator does not support addition.");
    }

    @Override
    public double subtract(double a, double b) {
        return a - b;
    }

    @Override
    public double multiply(double a, double b) {
        throw new UnsupportedOperationException("SubtractionCalculator does not support multiplication.");
    }

    @Override
    public double divide(double a, double b) {
        throw new UnsupportedOperationException("SubtractionCalculator does not support division.");
    }
}

class MultiplicationCalculator implements ICalculator {
    @Override
    public double add(double a, double b) {
        throw new UnsupportedOperationException("MultiplicationCalculator does not support addition.");
    }

    @Override
    public double subtract(double a, double b) {
        throw new UnsupportedOperationException("MultiplicationCalculator does not support subtraction.");
    }

    @Override
    public double multiply(double a, double b) {
        return a * b;
    }

    @Override
    public double divide(double a, double b) {
        throw new UnsupportedOperationException("MultiplicationCalculator does not support division.");
    }
}

class DivisionCalculator implements ICalculator {
    @Override
    public double add(double a, double b) {
        throw new UnsupportedOperationException("DivisionCalculator does not support addition.");
    }

    @Override
    public double subtract(double a, double b) {
        throw new UnsupportedOperationException("DivisionCalculator does not support subtraction.");
    }

    @Override
    public double multiply(double a, double b) {
        throw new UnsupportedOperationException("DivisionCalculator does not support multiplication.");
    }

    @Override
    public double divide(double a, double b) {
        return a / b;
    }
}

// 策略上下文类
class CalculatorContext {
    private ICalculator calculator;

    public CalculatorContext(ICalculator calculator) {
        this.calculator = calculator;
    }

    public double calculate(double a, double b, String operation) {
        switch (operation) {
            case "+":
                return calculator.add(a, b);
            case "-":
                return calculator.subtract(a, b);
            case "*":
                return calculator.multiply(a, b);
            case "/":
                return calculator.divide(a, b);
            default:
                throw new IllegalArgumentException("Invalid operation: " + operation);
        }
    }
}

// 使用策略模式
CalculatorContext context = new CalculatorContext(new AdditionCalculator());
double result = context.calculate(10, 20, "+");
System.out.println("Addition result: " + result);

context = new CalculatorContext(new SubtractionCalculator());
result = context.calculate(20, 10, "-");
System.out.println("Subtraction result: " + result);

context = new CalculatorContext(new MultiplicationCalculator());
result = context.calculate(10, 20, "*");
System.out.println("Multiplication result: " + result);

context = new CalculatorContext(new DivisionCalculator());
result = context.calculate(20, 10, "/");
System.out.println("Division result: " + result);