java - 根据Java中对象的类型选择实现

我有一个父母类型

public class IObject{}

并且可以有很多子类（甚至将来会有新的子类）

public class Object1 extends IObject{}
public class Object2 extends IObject{}
public class Object3 extends IObject{}
...
public class ObjectN extends IObject{}

然后，根据这些对象的类型，我必须执行不同的操作。

public class StrategyForObject1(){void do{}}
public class StrategyForObject2(){void do{}}
public class StrategyForObject3(){void do{}}
...
public class StrategyForObjectN(){void do{}}

所以我想从我的上下文类：

   public Conext {
    IObject o;

    public void setObject(IObject o) {
        this.o = o;
    }

    void logic() {
        if (o instanceOf Object1) {
            new StrategyForObject1().do();
        }
        if (o instanceOf Object2) {
            new StrategyForObject2().do();
        }
        if (o instanceOf Object3) {
            new StrategyForObject3().do();
        }
        ...
        if (o instanceOf ObjectN) {
            new StrategyForObjectN().do();
        }
    }
}

因此，基于类型可以执行不同的算法，但是如果我需要添加IObject的新子类，而只是添加新的StrategyForObject**N**类，而不需要更改Conext，我希望像策略模式一样可扩展。类。
在策略模式中，我们必须指定策略，但是在这里我们必须做相反的事情：根据对象的类型选择策略。如何以最佳方式在Java中做到这一点？

编辑：
IObject不能更改以添加其他方法。
我必须将逻辑与数据分开，因此不希望在Object1类中添加逻辑的实现。

最佳答案

我认为您需要实现访客模式。基本上，对于您所拥有的东西，它看起来像这样：

interface IObjectVisitor {
    void visit(IObject1 obj1);
    void visit(IObject2 obj2);
    ...
    void visit(IObjectN objN);
}
interface IObjectVisitable {
    void accept(IObjectVisitor visitor);
}
public abstract class IObject implements IObjectVisitable {
   ...
}
public class IObject1 extends IObject {
    public void accept(IObjectVisitor visitor) {
        visitor.visit(this);
    }
}
public class IObject2 extends IObject {
    public void accept(IObjectVisitor visitor) {
        visitor.visit(this);
    }
}
...
public class IObjectN extends IObject {
    public void accept(IObjectVisitor visitor) {
        visitor.visit(this);
    }
}
public class SomeLogicIObjectVisitor implements IObjectVisitor {
    void visit(IObject1 obj1) {
        //something with obj1
    }
    void visit(IObject2 obj2) {
        //something with obj2
    }
    ...
    void visit(IObjectN objN) {
        //something with objN
    }
}

然后，您需要像这样将某些逻辑应用于某些IObject：

public void someLogic(IObject obj) {
    SomeLogicIObjectVisitor visitor = new SomeLogicIObjectVisitor():
    visitor.visit(obj);
}

明智的面向对象，这是您可以实现的最佳模式。原因是因为它允许您采用适当的关注点分离，采用模块化和可扩展的方法。例如，看看@ nhouser9提供的答案。乍看之下，在IObject中定义abstract void do();似乎可以正常工作，但是您会将业务逻辑嵌入域对象中，而域对象很可能不属于该对象。另外，如果现在考虑其他逻辑，可以称之为“ logic2”，现在除了在每个IObject实现上创建abstract void do2();，然后继续在其中嵌入业务逻辑之外，别无选择。使用访问者模式，IObject实现不会改变，并且您也不会在IObjects中嵌入任何逻辑，只需创建一个新的访问者Logic2IObjectVisitor并在那里实现每个IObject实现的逻辑即可。您可以这样称呼它：

public void someLogic2(IObject obj) {
    Logic2IObjectVisitor visitor = new Logic2IObjectVisitor():
    visitor.visit(obj);
}

关于java - 根据Java中对象的类型选择实现，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/36668724/