Question

我在java中实现工厂设计模式，我希望在抽象类中保留一个重载方法。它会违反工厂模式的概念吗？或者请说明这是否是实施工厂设计模式的正确方法？

abstract class A{
    void meth(int a);
    void meth(int a,int b);
}

class Factory{
    public static A factoryMethod(int a){
         if(a==1){
            return new Ob1();
        }else{
            return new Ob2();
        }
    }
}

class Ob1 extends A{

void meth(int a){}
void meth(int a,int b){}
}

Answer 1

首先要实现Factory Pattern，您需要考虑Factory将产生什么。让我们产生Vehicles。

public VehicleFactory {
   public Vehicle newVehicle(String type) {
      ...
   }
}

将根据下面的类层次结构生成Vehicles。

public interface Vehicle {
   public List<Door> getDoors();
}

public class Motorcycle implements Vehicle {
   public List<Door> getDoors() {
       return Collections.<Door>emptyList();
   }
}

public class SportsCar implements Vehicle {
   public List<Door> getDoors() {
       return Collections.<Door>unmodifiableList(Arrays.asList(new Door("driver"), new Door("passenger"));
   }
}

public class Hatchback implements Vehicle {
       public List<Door> getDoors() {
       return Collections.<Door>unmodifiableList(Arrays.asList(new Door("driver"), new Door("passenger"), new Door("back"));
   }
}

然后，您的VehicleFactory方法newVehicle(...)可能看起来像

public Vehicle newVehicle(String type) {
    if ("motorcycle".equals(type)) { return new Motorcycle(); }
    if ("sports car".equals(type)) { return new SportsCar(); }
    if ("hatchback".equals(type)) { return new Hatchback(); }
    return null;
}

现在主要问题是“你为什么要这样做？”

有时你需要一个漂亮的干净界面来构建很多相关项目。您为相关项目提供了接口和工厂建立它们。这允许有人使用这部分软件只需拉入Interface类和ItemFactory即可。他们没有查看个别详细信息，简化其代码。

由于您隐藏了上述代码中所有Vehicles的实现细节，如果您遇到编程错误（或想要添加某些内容），您可以修复其中一个Vehicles（或向工厂添加新的Vehicle）并重新发布包含VehicleFactory的库（JAR文件）。

你知道其他人一直在使用VehicleFactory方法，所以你不必担心他们的代码在编译时会中断，除非你粗心大意，否则你也可以保证它会在运行时。

这与说行为不会改变不同。将返回Vehicle的新实现，希望减少嵌入的错误。此外，由于他们没有要求“新车”，你可能已经添加了他们不会看到它们，直到他们拨打newVehicle("station wagon")或类似的东西。

此外，您可以更改Vehicles的构建方式。例如，如果您以后决定不想要一个简单的“只需一次构造它”的实现样式，那么可以像这样改变'newVehicle（...）'

 public Vehicle newVehicle(String type) {
    Chassis chassis;
    if ("motorcycle".equals(type)) {
       chassis = new TwoWheelChassis();
    } else {
       chassis = new FourWheelChassis();
    }
    return new ComponentVehicle(chassis, getDoorCount(type));
 }

其中ComponentVehicle实现Vehicle，并且出于某种原因需要明确的Chassis对象。

---更新了评论中的“方法数量”问题---

Factory pattern并不是关于方法的数量，而是关于一种能够从一个或多个具体事物中构建抽象事物的方法。

所以在上面的例子中，我可以

public VehicleFactory {
    public Vehicle newVehicle(String type) { ... }
    public Vehicle newRedVehicle(String type) { ... }
    public Vehicle newBlackVehicle(String type) { ... } 
}

对于Vehicle的类型，它们都是可接受的工厂方法，但就Vehicle的颜色而言，它们不是面向工厂的方法。

要获得可以同时处理Type和Color的工厂方法，工厂方法

    public Vehicle newVehicle(String type, String color) { ... }

可能会被添加。请注意，有时某些组合没有任何意义，因此将所有工厂方法打包到单个工厂方法中可能是不值得的。

工厂对象中的任何方法实际上都不是工厂方法，除非它有可能返回多个基本类型的接口。同样，如果必须指定如何在方法之外构建对象，则它不是工厂方法。

如果您需要将如何构建Vehicle的控制权传递给您的“它本来就是工厂”方法的客户端，同时提供一些安全性，他们以理智的方式使用它，您需要Builder pattern 1}}。有关Builder Pattern如何不同的示例可以在下面的客户端代码中看到

 VehicleBuilder builder = new VehicleBuilder();
 builder.addDoor("driver");
 builder.addDoor("passenger");
 builder.paintVehicle("red");
 Vehicle vehicle = builder.getVehicle();

Answer 2

工厂模式是一个含糊的术语，不是吗？有简单工厂，工厂方法和抽象工厂。我想你在这里谈的是一个简单的工厂。 https://www.codeproject.com/Articles/1131770/Factory-Patterns-Simple-Factory-Pattern

Answer 3

这是Java工厂实现的示例。

比方说，我们需要创建多种货币支持，并且代码也应该可扩展以适应新的货币。在这里，我们将货币作为接口，所有货币将作为货币接口的具体实现。

Factory类将根据国家/地区创建货币，并返回具体实现，并将其存储在接口类型中。这使代码具有动态性和可扩展性。

这是Java Factory模式的完整代码示例。

Currency类：

interface Currency {
       String getSymbol();
}
// Concrete Rupee Class code
class Rupee implements Currency {
       @Override
       public String getSymbol() {
              return "Rs";
       }
}

// Concrete SGD class Code
class SGDDollar implements Currency {
       @Override
       public String getSymbol() {
              return "SGD";
       }
}

// Concrete US Dollar code
class USDollar implements Currency {
       @Override
       public String getSymbol() {
              return "USD";
       }
}

Factory：

// Factory Class code
class CurrencyFactory {

       public static Currency createCurrency (String country) {
       if (country. equalsIgnoreCase ("India")){
              return new Rupee();
       }else if(country. equalsIgnoreCase ("Singapore")){
              return new SGDDollar();
       }else if(country. equalsIgnoreCase ("US")){
              return new USDollar();
        }
       throw new IllegalArgumentException("No such currency");
       }
}

// Factory client code
public class Factory {
       public static void main(String args[]) {
              String country = args[0];
              Currency rupee = CurrencyFactory.createCurrency(country);
              System.out.println(rupee.getSymbol());
       }
}

查看更多Java Factory pattern示例。

我在java

3 个答案: