避免强制转换和 instanceOf

Question

我有一个界面

public interface Details {
   // nothing needed until now
}

在如下类中使用：

public class Value {
    // many fields
    private Details details;

    public Value(SomeType type) {
        switch (type) {
        case TYPE_1:
        case TYPE_2:
            this.details = new DetailsA();
            break;
        case TYPE_3:
            this.details = new DetailsB();
            break;
        default:
            throw new NotImplementedException("not yet implemented");
        }
    }

    public Details getDetails() {
        return this.details;
    }
}

接口有两种实现

public class DetailsA implements Details {

    private BigDecimal betragA;

    public DetailsA() {
    }

    public BigDecimal getBetragA() {
      return this.betragA;
    }

    public void setBetragA(BigDecimal betragA) {
      this.betragA = betragA;
   }

}

public class DeailsB implements Details {

    private BigDecimal betragB;
    private boolean booleanB;

    public BetragB() {
    }

    public BigDecimal getBetragB() {
        return this.betragB;
    }

    public void setBetragB(BigDecimal betragB) {
        this.betragB = betragB;
    }

    public boolean isBooleanB() {
        return this.booleanB;
    }

    public void setBooleanB(boolean booleanB) {
        this.booleanB = booleanB;
    }

    // some more fields

}

我有一个模型类，我想在其中使用这些细节，具体取决于实例。

 public class Model extends AbstractModel {

    private Details details;

    public void init(StoerungValue stoerung) {
        setDetails(stoerung.getSchaden().getDetails());
    }

    private void setDetails(Details details) {
        this.details = details;
    }
    // ...

在那里我有一些类似以下的操作

    // ...  
    public void setBooleanB(boolean booleanB) {
        if (details instanceof DetailB) {
            ((DetailB) details).setBooleanB(booleanB);
        }
    }
    // ...

我怎样才能避免这种强制转换和 instanceOf 的东西？是否有任何设计模式适用于此？

Answer 1

我认为您在这里遇到的问题是设计气味的集合。你已经把自己画到了一个角落里，可能没有一个简单的出路。我不知道这个解决方案是否适合你，但你至少可以考虑一下。

第一个设计味道是您创建了一个实际不存在的继承关系。简而言之，植根于Details 的层次结构违反了Liskov Substitution Principle。当一个类声称（如Model 那样）支持Details 接口时，它声称Details 的任何 实现都可以。程序的正确性和行为不应该改变，无论是给定DetailsA、DetailsB，还是一些尚未发明的FooDetails 类。

现实情况是DetailsA 和DetailsB 实际上并不相关。您可以看到这一点，因为Details 没有方法，因此也可能是任何两个类已经继承自的Object。

第二种设计气味是“功能嫉妒”。似乎Model 的许多方法只是对其底层details 属性的传递调用。您可以考虑，而不是在Model 上使用setBooleanB，而只是提供一个getDetails 方法，然后让调用者直接在Details 对象上工作。这不会删除 instanceof 检查或强制转换，但会将它们移出此类。

这里的第三件事与前两个有关。 Model 不依赖于 Details，因为它的属性类型会告诉你，而是依赖于（至少）DetailsB。如果是这样，那么它的属性类型应该这样说。现在，有时您可能需要Model 和DetailsA 并且有时您需要Model 和DetailsB，但它不能两者同时。在这种情况下，您可以使用泛型解决此问题。

首先，将Model 类设为泛型，并使用一个类型参数来说明其底层Details 实际上必须是什么。

public abstract class Model<T extends Details> {
    private T details;

    public void init(T dets) {
        setDetails(dets);
    }

    public void setDetails(T dets) {
        this.details = dets;
    }

    public T getDetails() {
        return this.details;
    }
}

然后，创建两个绑定到不同Details 类型的子类，从而可以承诺做正确的事情，而不需要强制转换或调用 instanceof。

public class ModelA extends Model<DetailsA> {
    public BigDecimal getBetragA() {
        return this.getDetails().getBetragA();
    }
}

public class ModelB extends Model<DetailsB> {
    public boolean getBooleanB() {
        return this.getDetails().isBooleanB();
    }

    public void setBooleanB(boolean boolB) {
        this.getDetails().setBooleanB(boolB);
    }
}

我不确定这是否能解决您的问题，但这是需要考虑的问题。