design-patterns - 复合设计模式 - 如何创建计算器

Question

我想探讨递归方法和复合设计模式之间的区别。复合设计模式让我想起了树形结构。因此，如果我必须写出它在类图中的外观，我们可以这样:



记住这个类图，这是我目前在 Java 中的内容；但我不介意伪代码。

让我们创建一个叶子:

class NumericOperand extends ArithmeticExpression{

    public Float add(String:s1,String:s2){
        return s1.toFloat() + s2.toFloat()
    }

    public Float minus(String:s1,String:s2){
        return s1.toFloat() - s2.toFloat()
    }

    public Float multiple(String:s1,String:s2){
        return s1.toFloat() * s2.toFloat()
    }

    public Float divide(String:s1,String:s2){
        return s1.toFloat() / s2.toFloat()
    }
}

现在让我们定义复合:

public CompositeOperand extends ArithmeticExpression{

    private List<NumericOperand> operandList = new ArrayList<NumericOperand>();
    //now what ???   
    //here im a little lost what i should do ? can you help me ? 
}

在复合 Material 中，我应该准确检查什么？显然，我需要以某种方式知道它是运算符还是整数，但我不知道如何将它们组合在一起。

Answer 1

这是使用复合设计模式实现的算术运算的一个示例。有许多方法可以实现算术。这里的类设计只是为了突出模式，不一定要描绘“最佳”解决方案。

该模式以 Component 接口(interface)开始，该接口(interface)由 Leafs 和 Composites 共享。

public interface Arithmetic {
    double compute();
    default void appendChild(Arithmetic arithmetic) {}
    default void removeChild(Arithmetic arithmetic) {}
}

接下来，我们有叶子节点，每个节点都代表一个单一的操作。

public class Addition implements Arithmetic {
    private final double x;
    private final double y;

    public Addition(double x, double y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public double compute() {
        return x + y;
    }
}

public class Subtraction implements Arithmetic {
    private final double x;
    private final double y;

    public Subtraction(double x, double y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public double compute() {
        return x - y;
    }
}

最后是一个复合节点，它代表多个操作。

public class CompositeAddition implements Arithmetic {
    private final List<Arithmetic> operations = new ArrayList<>();

    public CompositeAddition(Arithmetic... arithmetics) {
        operations.addAll(Arrays.asList(arithmetics));
    }

    @Override
    public double compute() {
        return operations.stream().mapToDouble(Arithmetic::compute).sum();
    }

    @Override
    public void appendChild(Arithmetic arithmetic) {
        operations.add(arithmetic);
    }

    @Override
    public void removeChild(Arithmetic arithmetic) {
        operations.remove(arithmetic);
    }
}

我把剩下的算术类型留给读者练习。这几个类足以进行演示。

public class Main {
    public static void main(String... args) {
        Arithmetic fivePlusTwo = new Addition(5,2);
        Arithmetic fiveMinusTwo = new Subtraction(5,2);
        Arithmetic sevenPlusThree = new CompositeAddition(fivePlusTwo, fiveMinusTwo);
        System.out.println(sevenPlusThree.compute());
    }
}

设计模式的关键点是所有操作，无论是单一的还是多重的，都可以通过同一个界面查看。这样，一个客户端收到 Arithmetic对象能够 compute()他们不知道它们是叶子还是复合物。