Question

我有一个执行以下操作的方法：

private void computeHierarchie(GlobalKey key) {
    HierarchieValue hierarchieValue = hierarchieFactory.createHierarchie(selectedKey);
    ....
}

GlobalKey有4个孩子：KeyA，KeyB，KeyC和KeyD。

目前我的工厂看起来如下：

public class HierarchieFactory {

    // inject someFacade which has 4 different methods

    public HierarchieValue createHierarchie(GlobalKey key) {
        if (key instanceof KeyA) {
            return someFacade.computeHierarchie((KeyA) key);
        }
        if (key instanceof KeyB) {
            return someFacade.computeHierarchie((KeyB) key);
        }
        if (key instanceof KeyC) {
            return someFacade.computeHierarchie((KeyC) key);
        }
        if (key instanceof KeyD) {
            return someFacade.computeHierarchie((KeyD) key);
        }
        return new HierarchieValue();
    }

}

我真的不喜欢这种转换案例，但说实话，我无法计算任何有价值的重构。我试过以下的东西：

public abstract class AbstractHierarchieFactory {

    //inject someFacade

    abstract <T extends GlobalKey> HierarchieValue createHierarchie(T key);

}

然后是4个类扩展了这个类。一个看起来像：

public class KonzernHierarchieFactory extends AbstractHierarchieFactory {

    @Override
    HierarchieValue createHierarchie(KonzernKey konzernKey) {
        return evaFacade.computeHierarchie(konzernKey);
    }

}

这太好了！但遗憾的是，这种做法并不奏效。你有什么其他的建议？必须有一种标准的方法来解决这个问题。

Answer 1

这似乎是访客模式的一个主要示例。

e.g。假设您有方法KeyVisitor，...，visitA(KeyA key)的{{1}}界面。然后，您可以将方法编码到Key类中（显然也可以从公共基类中获取）：

visitD(KeyD key) X void visit(KeyVisitor visitor) { visitor.visit

将 X 替换为(this); } .. A的位置，具体取决于班级。现在，您的工厂可以实现D并单独处理您的密钥类。

如何避免转换和instanceOf

1 个答案: