Java接口：基于对象类型调用实现类

我有一个接口，它的两个实现是：

public interface ObjectProcessor {
  public void process(List<String> objectNames);
}

public CarImpl implements ObjectProcessor {
@override 
public void process(List<String> carNames){
//car logic
} }

public VanImpl implements ObjectProcessor {
@override 
public void process(List<String> vanNames){
//van logic
}
}

公共接口对象处理器{
公共作废流程（列出对象名称）；
}
公共CarImpl实现ObjectProcessor{
@凌驾
公共作废流程（名单）{
//汽车逻辑
} }
公共VanImpl实现ObjectProcessor{
@凌驾
公共作废流程（列表名称）{
//范逻辑
}
}

现在，使用此接口的调用方如下所示：

public void caller(VehicleType vehicleType, List<String> vehicleNames ) {
ObjectProcessor processor = null ;
 if (VehicleType == VehicleType.CAR) {
      processor = new CarImpl();
      processor.process(vehicleNames);
}
}

public void调用者（车辆类型车辆类型列表车辆名称）{
ObjectProcessor=null；
if（VehicleType==VehicleType.CAR）{
处理器=新的CarImpl（）；
处理程序（车辆名称）；
}
}

作为枚举的VehicleType 这个很好用。但是，我是否可以在没有
的情况下动态调用接口

---

添加if语句。在将来，如果我支持另一个车辆，我需要添加一个if语句以及接口的新实现。我怎样才能避免这种情况

像这样覆盖枚举中的抽象工厂方法

public enum VehicleType {
    Car {
        @Override
        public ObjectProcessor createImpl() {
            return new CarImpl();
        }
    },
    Van {
        @Override
        public ObjectProcessor createImpl() {
            return new VanImpl();
        }
    };
    public abstract ObjectProcessor createImpl();
}

public void caller(VehicleType vehicleType, List<String> vehicleNames ) {
    ObjectProcessor processor = vehicleType.createImpl();
    processor.process(vehicleNames);
}

public enum VehicleType {
    Car {
        @Override
        public ObjectProcessor createImpl() {
            return new ObjectProcessor() {

                @Override
                public void process(List<String> objectNames) {
                    // car logic
                }

            };
        }
    },
    Van {
        @Override
        public ObjectProcessor createImpl() {
            return new ObjectProcessor() {

                @Override
                public void process(List<String> objectNames) {
                    // van logic
                }

            };
        }
    };
    public abstract ObjectProcessor createImpl();
}

公共枚举车辆类型{
汽车{
@凌驾
公共对象处理器createImpl（）{
返回新的CarImpl（）；
}
},
货车{
@凌驾
公共对象处理器createImpl（）{
返回新的VanImpl（）；
}
};
公共抽象对象处理器createImpl（）；
}
公共无效调用方（VehicleType VehicleType，列出车辆名称）{
ObjectProcessor=vehicleType.createImpl（）；
处理程序（车辆名称）；
}

VechicleType将枚举与工厂相结合

或者您可以像这样在枚举中编写所有逻辑

public enum VehicleType {
    Car {
        @Override
        public ObjectProcessor createImpl() {
            return new CarImpl();
        }
    },
    Van {
        @Override
        public ObjectProcessor createImpl() {
            return new VanImpl();
        }
    };
    public abstract ObjectProcessor createImpl();
}

public void caller(VehicleType vehicleType, List<String> vehicleNames ) {
    ObjectProcessor processor = vehicleType.createImpl();
    processor.process(vehicleNames);
}

public enum VehicleType {
    Car {
        @Override
        public ObjectProcessor createImpl() {
            return new ObjectProcessor() {

                @Override
                public void process(List<String> objectNames) {
                    // car logic
                }

            };
        }
    },
    Van {
        @Override
        public ObjectProcessor createImpl() {
            return new ObjectProcessor() {

                @Override
                public void process(List<String> objectNames) {
                    // van logic
                }

            };
        }
    };
    public abstract ObjectProcessor createImpl();
}

公共枚举车辆类型{
汽车{
@凌驾
公共对象处理器createImpl（）{
返回新的ObjectProcessor（）{
@凌驾
公共作废流程（列出对象名称）{
//汽车逻辑
}
};
}
},
货车{
@凌驾
公共对象处理器createImpl（）{
返回新的ObjectProcessor（）{
@凌驾
公共作废流程（列出对象名称）{
//范逻辑
}
};
}
};
公共抽象对象处理器createImpl（）；
}

---

在这种情况下，您不再需要实现类（CarImpl、VanImpl等）。

使用工厂模式。以下是使用它的一些好处：

1） 工厂方法设计模式将调用类与目标类解耦，这会导致耦合更少且具有高度内聚性的代码

2） Java中的Factory模式使子类能够提供对象的扩展版本，因为在Factory中创建对象比直接在客户机中创建对象更灵活。由于客户机随时都在接口级别工作，所以您可以增强实现并从工厂返回

3） 在Java中使用Factory设计模式的另一个好处是，它鼓励代码的一致性，因为每次使用Factory而不是在不同的客户端使用不同的构造函数创建对象时

---

4） 使用Java中的Factory design模式编写的代码也很容易调试和排除故障，因为您有一个集中的对象创建方法，每个客户机都从同一个地方获取对象

您基本上实现的是一个Factory模式，如其他答案中所建议的。但最后，您必须编写一个“if”或“switch”语句来选择正确的枚举值实现（或策略）。但正如您所提到的，无论何时添加或删除枚举值，都必须扩展此选择模式。您可以使用如下地图来规避此问题：

public class ProcessorSelector {

    private final Map<VehicleType, ObjectProcessor> processors;

    public ProcessorSelector(Map<VehicleType, ObjectProcessor> processors) {
        this.processors = processors;
    }

    public void process(VehicleType type, List<String> input) {
        processors.get(type).process(input);
    }
}

---

您再也不必更改ProcessorSelector，只需更改类的构造/配置即可。事实上，你可以说我们刚刚在这里实施了战略模式。这些选择器类非常常见，如果您觉得经常要实现它们，甚至可以使用更通用的实现，我最近在一篇博客文章中描述了这一点：

使用a或a。我不确定，但使用反射可以帮助您，它将消除每次添加开关案例的开销。但是从时间复杂度来看，使用反射是一个代价高昂的过程。但是在您的解决方案中，每次查找都会得到相同的CarImpl或VanImpl实例。没错，如果您想要新实例，只需将实例替换为工厂，同样的原则也适用谢谢！这种方法正是我想要的