java - 使用哪种设计模式？

Question

我面临着一个基本的类设计相关问题，我确信这个问题很常见，但我没有一个令人信服的答案。这就是我的问题。我先放一下代码片段

public interface Value {
    void setValue(Object value);
    Object getValue();
}

public interface SimpleValue extends Value {
    void validate();
}

public interface CompoundValue extends Value{
    void setValueAt(int position, Value value);
    Value getValueAt(int position);
    void addValue(Value value);
    List<Value> getValues();
}

public class IntValue implements SimpleValue {
    @Override
    public void setValue(Object value) {
        // TODO Auto-generated method stub
    }
    @Override
    public Object getValue() {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public void validate() {
        // TODO Auto-generated method stub
    }
}

public class ComplexValue implements CompoundValue {
    private List<Value>  values;
    @Override
    public void setValue(Object value) {
        //Not useful
    }
    @Override
    public Object getValue() {
        //not useful
        return null;
    }
    @Override
    public void setValueAt(int position, Value value) {
        values.set(position, value);
    }
    @Override
    public Value getValueAt(int position) {
        return values.get(position);
    }
    @Override
    public List<Value> getValues() {
        return values;
    }
    @Override
    public void addValue(Value value) {
        values.add(value);
    }
}

public class Main {
    public static void main(String[] args) {
        Value simpleValue = new IntValue();
        Value simpleValue2 = new IntValue();
        ComplexValue complexValue = new ComplexValue();
        Value simpleValue3 = new IntValue();
        complexValue.addValue(simpleValue3);
        ComplexValue complexValue2 = new ComplexValue();
        complexValue2.addValue(simpleValue);
        complexValue2.addValue(simpleValue2);
        complexValue2.addValue(complexValue);
        Value value = complexValue2.getValueAt(2);
        if (value instanceof ComplexValue) {
            ComplexValue compValue = (ComplexValue) value;
            Value finalValue = complexValue.getValueAt(0);
        }
    }
}

正如您所看到的，我有一个接口(interface)“Value”，它有两种变体，一种包含“IntValue”等实际值，另一种可以容纳多个值。这些值可以是 simpleValue 或CompoundValue 对象

我的问题是处理一个 ComplexValue 对象，我总是必须相应地检查它的实际类和类型转换以获得它们的功能，从设计角度来看，这看起来不是一个像样的 API 设计。

如果有人能够指导我针对此问题提供合适的设计指南或此处使用的任何设计模式，我将不胜感激。

谢谢。

Answer 1

这是一个简短的答案，但一般来说，解决此类问题的方法是使用多态性。

您有这两种不同类型的值，并且您的代码逻辑根据类型执行不同的操作。现在，您正在通过决策“在外部”进行此操作:

if(theValue instanceof CompoundValue) {
    // perform CompoundValue action
} else if(theValue instanceof SimpleValue) {
    // perform SimpleValue action
}

但是theValue已经知道它是什么类型的Value。因此，通常处理此问题的方法是在界面中包含此操作，例如:

interface PolyValue extends Value {
    public void perform();
}

现在你有了CompoundValue:

class CompoundValue implements PolyValue {
    @Override
    public void perform() {
        // perform CompoundValue action
    }
    ...
}

和简单值:

class SimpleValue implements PolyValue {
    @Override
    public void perform() {
        // perform SimpleValue action
    }
    ...
}

有许多设计模式可以处理这种情况。

• Strategy
• Command
• Visitor

仅举几例。这三个是同一想法的变体，重点是摆脱决策逻辑。