哪种Java设计模式最适合包含循环的if-else语句？

Question

如果没有，我有一个7-8的用例。 示例用例：

 String type;
 List < Entity > entityList;


 if (type.equals("A")) {
    ClassA a = new ClassA();
    a.performTask();

    for (Entity e: entitylist) {
        // do some task
    }
 }

  else if (type.equals("B")) {
    ClassB b = new ClassB();
    b.performTask();

    for (Entity e: entitylist) {
        // do some different task
    }
 }

在这种情况下，哪种Java设计模式最合适，因为我想消除这种梯形图？

Answer 1

如果您真的想在这种情况下使用设计模式，则建议使用“ 访客模式” 。 据我所知，这是最适合这种“类型检查”的代码。 您可以在这里找到一个很好的例子。 但是，正如评论中最近提到的那样，我同意在这种情况下采用某种模式会产生大量开销。

Answer 2

为所有任务引入接口并使用工厂模式。 工厂可以在内部使用地图。 例如

public class TaskFactory {

    private Map<String, Class<? extends Task>> taskTypeMap = new HashMap<String, Class<? extends Task>>();

    public TaskFactory() {
        taskTypeMap.put("A", ATask.class);
        taskTypeMap.put("B", BTask.class);
    }

    public Task createTask(String type) {
        Class<? extends Task> taskType = taskTypeMap.get(type);

        if (taskType == null) {
            throw new IllegalArgumentException("Task type " + type
                    + " is not supported");
        }

        try {
            return taskType.newInstance();
        } catch (Exception e) {
            throw new IllegalStateException(
                    "Unable to instantiate Task of type " + taskType, e);
        }
    }

}

您的客户代码将更改为

String type = ...;
List<Entity> entityList = ...;

TaskFactory taskFactory = new TaskFactory();
Task task = taskFactory.createTask(type);

task.performTask();

for (Entity e: entitylist) {
    // do some task
}

Answer 3

工厂实现如下所示：

public class WidgetFactory {
    public static void main(String[] args) {
        String type = "A";
        List<Entity> entityList = new ArrayList<>();

        Widget widget = WidgetFactory.createWidget(type);
        widget.performTask();
        for (Entity e : entityList) {
            widget.performTaskOnEntity(e);
        }
    }

    private static Widget createWidget(String type) {
        switch (type) {
            case "A":
                return new ClassA();
            case "B":
                return new ClassB();
            default:
                throw new IllegalArgumentException("Unknown type: " + type);
        }
    }

    private interface Widget {
        void performTask();
        void performTaskOnEntity(Entity entity);
    }

    private static class ClassA implements Widget {
        public void performTask() { }
        public void performTaskOnEntity(Entity entity) { }
    }

    private static class ClassB implements Widget {
        public void performTask() { }
        public void performTaskOnEntity(Entity entity) { }
    }

    private static class Entity {
    }
}

Answer 4

您需要以下模式才能使此设计通用-

1. 工厂模式 -创建一个BaseClass 。 A，B（和C ...）类应扩展此BaseClass。 BaseClass应该有一个抽象方法performTask（），应该由A类和B类（和C ...）实现，以使其成为具体实现

2. 模板模式 -让我们为模板定义一个基类-BaseTemplateClass 。 现在，我在这里使用模板模式的原因是，您在此流程中有3个不同的步骤-

   第1步 -创建BaseClass的新实例（我们将使用第1步中定义的Factory来执行此操作）。 CreateInstance（）将是TemplateBaseClass中的第一个具体方法，它将接收字符串参数标识符并调用工厂。 由于这是固定的步骤，因此我们将CreateInstance（）保留为具体方法。

   第2步 -将调用BaseClass的performTask（）。 这将是抽象的。

   步骤3 -processEntityList（）方法将包含for循环。 这也是包含for循环调用的具体方法-for（实体e：实体列表）{..}

   最后 ，我们需要BaseTemplateClass中的execute（）方法，该方法调用步骤1、2和3中定义的3个方法。

根据其需要，BaseTemplateClass的实现将仅具有抽象方法performTask（）的实现-在这种情况下，仅调用A，B（或C ...）的performtask（）。 但是，如果需要对A，B（或C ...）进行更多处理，这将很有帮助。

客户端（用传统术语来说）只需要调用BaseTemplateClass的适当实现实例的execute（）方法，其余操作将按照上述设计进行。