工厂模式。 什么时候使用工厂方法？

Question

什么时候在对象中使用工厂方法而不是工厂类是个好主意？

Answer 1

清楚地区分使用工厂或工厂方法背后的想法很重要。
两者都是为了解决相互排斥的不同类型的对象创建问题。

让我们具体说明一下“工厂方法”：

首先，当您开发库或 API 并将用于进一步的应用程序开发时，工厂方法是创建模式的最佳选择之一。 背后的原因； 我们知道何时创建具有所需功能的对象，但对象的类型将保持未定状态，或者将由传递的动态参数决定。

现在的要点是，通过使用工厂模式本身可以实现大致相同的效果，但是如果将工厂模式用于上述突出显示的问题，则会给系统带来一个巨大的缺点，那就是您创建不同对象（子类对象）的逻辑将特定于某些业务条件，因此将来当您需要为其他平台扩展库的功能时（从技术上讲，您需要添加更多基本接口或抽象类的子类，以便工厂除了现有对象之外还将返回这些对象基于一些动态参数）然后每次你需要改变（扩展）工厂类的逻辑，这将是昂贵的操作并且从设计角度来看不好。
另一方面，如果使用“工厂方法”模式来执行相同的操作，那么您只需要创建附加功能（子类）并通过注入动态注册它，这不需要更改您的基本代码。

interface Deliverable 
{
    /*********/
}

abstract class DefaultProducer 
{

    public void taskToBeDone() 
    {   
        Deliverable deliverable = factoryMethodPattern();
    }
    protected abstract Deliverable factoryMethodPattern();
}

class SpecificDeliverable implements Deliverable 
{
 /***SPECIFIC TASK CAN BE WRITTEN HERE***/
}

class SpecificProducer extends DefaultProducer 
{
    protected Deliverable factoryMethodPattern() 
    {
        return new SpecificDeliverable();
    }
}

public class MasterApplicationProgram 
{
    public static void main(String arg[]) 
    {
        DefaultProducer defaultProducer = new SpecificProducer();
        defaultProducer.taskToBeDone();
    }
}

Answer 2

我喜欢从我的类是“人”的角度来思考设计模式，这些模式是人们相互交谈的方式。

所以，对我来说，工厂模式就像一个招聘机构。 你有人需要不同数量的工人。 这个人可能知道他们所雇用的人需要的一些信息，但仅此而已。

因此，当他们需要新员工时，他们会致电招聘机构并告诉他们需要什么。 现在，要实际雇用某人，您需要了解很多东西 - 福利、资格验证等。但雇用的人不需要知道这些 - 招聘机构会处理所有这些那。

同样，使用工厂允许消费者创建新对象，而无需知道它们如何创建的详细信息，或者它们的依赖项是什么 - 他们只需要提供他们真正想要的信息。

public interface IThingFactory
{
    Thing GetThing(string theString);
}

public class ThingFactory : IThingFactory
{
    public Thing GetThing(string theString)
    {
        return new Thing(theString, firstDependency, secondDependency);
    }
}

因此，现在 ThingFactory 的消费者可以获取一个 Thing，而无需了解该 Thing 的依赖关系，除了来自消费者的字符串数据。

Answer 3

我个人认为单独的 Factory 类有意义的一种情况是，当您尝试创建的最终对象依赖于其他几个对象时。 例如，在 PHP 中：假设您有一个 House 对象，该对象又具有一个 Kitchen 和一个 LivingRoom 对象，并且 LivingRoom 对象内部也有一个 TV 对象。

实现此目的的最简单方法是让每个对象在其构造方法上创建其子对象，但如果属性相对嵌套，当您的 House 创建失败时，您可能会花一些时间尝试准确隔离哪些属性失败。

另一种方法是执行以下操作（依赖注入，如果您喜欢这个花哨的术语）：

$TVObj = new TV($param1, $param2, $param3);
$LivingroomObj = new LivingRoom($TVObj, $param1, $param2);
$KitchenroomObj = new Kitchen($param1, $param2);
$HouseObj = new House($LivingroomObj, $KitchenroomObj);

这里，如果创建 House 的过程失败，则只有一个地方可以查看，但必须每次都使用此块当一个人想要一套新的房子时，这实在是太不方便了。 输入工厂：

class HouseFactory {
    public function create() {
        $TVObj = new TV($param1, $param2, $param3);
        $LivingroomObj = new LivingRoom($TVObj, $param1, $param2);
        $KitchenroomObj = new Kitchen($param1, $param2);
        $HouseObj = new House($LivingroomObj, $KitchenroomObj);

        return $HouseObj;
    }
}

$houseFactory = new HouseFactory();
$HouseObj = $houseFactory->create();

由于这里的工厂，创建 House 的过程被抽象化（因为当您只想创建一个 时，您不需要创建和设置每个依赖项House），同时集中化，使其更易于维护。 使用单独的工厂可能是有益的还有其他原因（例如可测试性），但我发现这个特定的用例可以最好地说明工厂类如何有用。

Answer 4

工厂方法应被视为构造函数的替代方案 - 大多数情况下当构造函数的表达能力不够时，即。

class Foo{
  public Foo(bool withBar);
}

表达能力不如：

class Foo{
  public static Foo withBar();
  public static Foo withoutBar();
}

当您需要复杂的过程来构造对象时，当构造需要实际类不需要的依赖项时，当您需要构造不同的对象等时，工厂类非常有用。

Answer 5

当您需要多个具有相同参数类型但具有不同行为的“构造函数”时，它们也很有用。

Answer 6

在以下情况下，在对象内部使用工厂方法是个好主意：

1. 对象的类不知道它必须创建哪些确切的子类
2. 子类指定
3. 对象的类被设计为使其创建的对象由对象的 类将其职责委托给辅助子类，并且不知道具体的类将承担这些职责。

在以下情况下使用抽象工厂类是个好主意：

1. 您的对象不应依赖于其内部对象的方式创建和设计
2. 链接对象组应该一起使用，并且您需要满足此约束
3. 对象应该由几个可能的链接对象系列之一进行配置，这些链接对象将成为父对象的一部分
4. 需要共享显示接口的子对象仅但不是实施

Answer 7

问题陈述：使用工厂方法创建游戏工厂，定义游戏界面。

代码片段：

import java.util.HashMap;


/* Product interface as per UML diagram */
interface Game{
    /* createGame is a complex method, which executes a sequence of game steps */
    public void createGame();
}

/* ConcreteProduct implementation as per UML diagram */
class Chess implements Game{
    public Chess(){
        
    }
    public void createGame(){
        System.out.println("---------------------------------------");
        System.out.println("Create Chess game");
        System.out.println("Opponents:2");
        System.out.println("Define 64 blocks");
        System.out.println("Place 16 pieces for White opponent");
        System.out.println("Place 16 pieces for Black opponent");
        System.out.println("Start Chess game");
        System.out.println("---------------------------------------");
    }
}
class Checkers implements Game{
    public Checkers(){
       
    }
    public void createGame(){
        System.out.println("---------------------------------------");
        System.out.println("Create Checkers game");
        System.out.println("Opponents:2 or 3 or 4 or 6");
        System.out.println("For each opponent, place 10 coins");
        System.out.println("Start Checkers game");
        System.out.println("---------------------------------------");
    }
}
class Ludo implements Game{
    public Ludo(){
        
    }
    public void createGame(){
        System.out.println("---------------------------------------");
        System.out.println("Create Ludo game");
        System.out.println("Opponents:2 or 3 or 4");
        System.out.println("For each opponent, place 4 coins");
        System.out.println("Create two dices with numbers from 1-6");
        System.out.println("Start Ludo game");
        System.out.println("---------------------------------------");
    }
}

/* Creator interface as per UML diagram */
interface IGameFactory {
    public Game getGame(String gameName);
}

/* ConcreteCreator implementation as per UML diagram */
class GameFactory implements IGameFactory {
        
     HashMap<String,Game> games = new HashMap<String,Game>();
    /*  
        Since Game Creation is complex process, we don't want to create game using new operator every time.
        Instead we create Game only once and store it in Factory. When client request a specific game, 
        Game object is returned from Factory instead of creating new Game on the fly, which is time consuming
    */
    
    public GameFactory(){
        
        games.put(Chess.class.getName(),new Chess());
        games.put(Checkers.class.getName(),new Checkers());
        games.put(Ludo.class.getName(),new Ludo());        
    }
    public Game getGame(String gameName){
        return games.get(gameName);
    }
}

public class NonStaticFactoryDemo{
    public static void main(String args[]){
        if ( args.length < 1){
            System.out.println("Usage: java FactoryDemo gameName");
            return;
        }
     
        GameFactory factory = new GameFactory();
        Game game = factory.getGame(args[0]);
        if ( game != null ){                    
            game.createGame();
            System.out.println("Game="+game.getClass().getName());
        }else{
            System.out.println(args[0]+  " Game does not exists in factory");
        }           
    }
}

输出：

java NonStaticFactoryDemo Chess
---------------------------------------
Create Chess game
Opponents:2
Define 64 blocks
Place 16 pieces for White opponent
Place 16 pieces for Black opponent
Start Chess game
---------------------------------------
Game=Chess

此示例通过实现 FactoryMethod 显示了一个 Factory 类。

1. Game 是所有类型游戏的界面。 它定义了复杂的方法：createGame()

2. Chess、Ludo、Checkers是游戏的不同变体，它们为createGame()提供了实现

3. public Game getGame(String gameName) 是IGameFactory 类中的 FactoryMethod

4. GameFactory 预先创建不同类型的构造函数中的游戏。 它实现了 IGameFactory 工厂方法。

5. 游戏名称作为命令行参数传递给NotStaticFactoryDe​​mo

6. GameFactory 中的getGame 接受游戏名称并返回相应的 Game 对象。

   


定义来自维基百科/四人帮（《设计模式：可重用面向对象软件的元素》一书）

工厂：创建对象而不向客户端公开实例化逻辑。

工厂方法：定义用于创建对象的接口，但让子类决定实例化哪个类。 工厂方法让类将其使用的实例化推迟到子类。”（四人帮）

用例：

何时使用：客户端不知道它将使用哪些具体类需要在运行时创建对象，它只是想获得一个可以完成这项工作的类。

Answer 8

当工厂类返回的对象类型具有私有构造函数时，当不同的工厂类在返回的对象上设置不同的属性时，或者当特定的工厂类型与其返回的具体类型耦合时，工厂类非常有用。

WCF 使用 ServiceHostFactory 类在不同情况下检索 ServiceHost 对象。 IIS 使用标准 ServiceHostFactory 检索 .svc 文件的 ServiceHost 实例，但 WebScriptServiceHostFactory 用于将序列化返回到 JavaScript 客户端的服务。 ADO.NET 数据服务有其自己特殊的 DataServiceHostFactory，而 ASP.NET 也有其 ApplicationServicesHostFactory，因为其服务具有私有构造函数。

如果您只有一个类使用工厂，那么您可以只在该类中使用工厂方法。

Answer 9

这确实是一个品味问题。 工厂类可以根据需要进行抽象/接口，而工厂方法重量更轻（并且也往往是可测试的，因为它们没有定义的类型，但它们需要一个众所周知的注册点，类似于服务定位器，但用于定位工厂方法）。

Answer 10

考虑一个必须设计 Order 和 Customer 类的场景。 为了简单性和初始要求，您不需要 Order 类的工厂，并用许多“new Order()”语句填充您的应用程序。 一切进展顺利。

现在出现了一个新的要求，即如果没有客户关联（新依赖项），则无法实例化订单对象。 现在您有以下考虑。

1-您创建构造函数重载，该重载仅适用于新的实现。 （不能接受的）。
2-您更改 Order() 签名并更改每个调用。 （这不是一个好的做法，而且是真正的痛苦）。

相反，如果您已经为订单类创建了一个工厂，那么您只需更改一行代码就可以了。 我建议几乎每个聚合关联都使用工厂类。 希望有帮助。

Answer 11

GOF 定义：

定义一个用于创建对象的接口，但让子类决定实例化哪个类。 工厂方法让类将实例化推迟到子类。

通用示例：

public abstract class Factory<T> {

    public abstract T instantiate(Supplier<? extends T> supplier);

}

具体类

public class SupplierFactory<T> extends Factory<T> {

    @Override
    public T instantiate(Supplier<? extends T> supplier) {
        return supplier.get();
    }
}

实现

public class Alpha implements BaseInterface {
    @Override
    public void doAction() {
        System.out.println("The Alpha executed");
    }
}

public class Beta implements BaseInterface {
    @Override
    public void doAction() {
        System.out.println("The Beta executed");
    }
}

public interface BaseInterface {
    void doAction();
}

public class Main {
    public static void main(String[] args) {
        Factory<BaseInterface> secondFactory = new SupplierFactory<>();
        secondFactory.instantiate(Beta::new).doAction();
        secondFactory.instantiate(Alpha::new).doAction();
    }
}

简介优点

• 您将可能变化的代码与不变的代码分开（即，使用简单工厂模式的优点是仍然存在）。 这种技术可以帮助您轻松维护代码。
• 你的代码没有紧密耦合； 因此，您可以随时在系统中添加新的类，如 Lion、Beer 等，而无需修改现有体系结构。 所以，你遵循了“禁止修改，开放扩展”的原则。

Answer 12

工厂类更加重量级，但给你带来了一定的优势。 如果您需要从多个原始数据源构建对象，它们允许您仅将构建逻辑（也可能是数据的聚合）封装在一个位置。 在那里可以抽象地测试它，而不用关心对象接口。

我发现这是一个有用的模式，特别是当我无法替换 ORM 且不充分并且希望从数据库表连接或存储过程有效实例化许多对象时。

Answer 13

我的简短解释是，当我们没有足够的信息来创建具体对象时，我们会使用工厂模式。 我们要么不知道依赖关系，要么不知道对象的类型。 而且我们几乎总是不知道它们，因为这是运行时提供的信息。

示例：我们知道必须创建一个车辆对象，但我们不知道它是否会飞或在地面上工作。

Answer 14

任何将需要使用的对象的对象创建推迟到其子类的类都可以视为工厂模式的示例。

我在另一个答案中详细提到了 https://stackoverflow.com/a/49110001/504133

Answer 15

我认为这取决于您想要为代码带来的松散耦合程度。

工厂方法可以很好地解耦事物，但工厂类不行。

换句话说，使用工厂方法比使用简单工厂（称为工厂类）更容易更改内容。

查看此示例： https://connected2know.com/programming/java-factory-pattern/ 。 现在，想象一下您想带一只新动物。 在工厂类中，您需要更改工厂，但在工厂方法中，不需要，您只需要添加一个新的子类。

Answer 16

我将工厂比作图书馆的概念。 例如，您可以拥有一个用于处理数字的库和另一个用于处理形状的库。 您可以将这些库的函数存储在逻辑命名的目录中，如 Numbers 或 Shapes。 这些是通用类型，可以包括整数、浮点数、双数、长整型或矩形、圆形、三角形、五边形（如果是形状）。

petter工厂使用多态性、依赖注入和控制反转。

工厂模式的既定目的是：定义用于创建对象的接口，但让子类决定实例化哪个类。 工厂方法让类将实例化推迟到子类。

因此，假设您正在构建一个操作系统或框架，并且正在构建所有离散组件。

这是 PHP 中工厂模式概念的一个简单示例。 我可能不是 100% 完全同意，但它只是作为一个简单的例子。 我不是专家。

class NumbersFactory {
    public static function makeNumber( $type, $number ) {
        $numObject = null;
        $number = null;

        switch( $type ) {
            case 'float':
                $numObject = new Float( $number );
                break;
            case 'integer':
                $numObject = new Integer( $number );
                break;
            case 'short':
                $numObject = new Short( $number );
                break;
            case 'double':
                $numObject = new Double( $number );
                break;
            case 'long':
                $numObject = new Long( $number );
                break;
            default:
                $numObject = new Integer( $number );
                break;
        }

        return $numObject;
    }
}

/* Numbers interface */
abstract class Number {
    protected $number;

    public function __construct( $number ) {
        $this->number = $number;
    }

    abstract public function add();
    abstract public function subtract();
    abstract public function multiply();
    abstract public function divide();
}
/* Float Implementation */
class Float extends Number {
    public function add() {
        // implementation goes here
    }

    public function subtract() {
        // implementation goes here
    }

    public function multiply() {
        // implementation goes here
    }

    public function divide() {
        // implementation goes here
    }
}
/* Integer Implementation */
class Integer extends Number {
    public function add() {
        // implementation goes here
    }

    public function subtract() {
        // implementation goes here
    }

    public function multiply() {
        // implementation goes here
    }

    public function divide() {
        // implementation goes here
    }
}
/* Short Implementation */
class Short extends Number {
    public function add() {
        // implementation goes here
    }

    public function subtract() {
        // implementation goes here
    }

    public function multiply() {
        // implementation goes here
    }

    public function divide() {
        // implementation goes here
    }
}
/* Double Implementation */
class Double extends Number {
    public function add() {
        // implementation goes here
    }

    public function subtract() {
        // implementation goes here
    }

    public function multiply() {
        // implementation goes here
    }

    public function divide() {
        // implementation goes here
    }
}
/* Long Implementation */
class Long extends Number {
    public function add() {
        // implementation goes here
    }

    public function subtract() {
        // implementation goes here
    }

    public function multiply() {
        // implementation goes here
    }

    public function divide() {
        // implementation goes here
    }
}

$number = NumbersFactory::makeNumber( 'float', 12.5 );

Answer 17

如果你想在使用方面创建不同的对象。 它是有益的。

public class factoryMethodPattern {
      static String planName = "COMMERCIALPLAN";
      static int units = 3;
      public static void main(String args[]) {
          GetPlanFactory planFactory = new GetPlanFactory();
          Plan p = planFactory.getPlan(planName);
          System.out.print("Bill amount for " + planName + " of  " + units
                        + " units is: ");
          p.getRate();
          p.calculateBill(units);
      }
}

abstract class Plan {
      protected double rate;

      abstract void getRate();

      public void calculateBill(int units) {
            System.out.println(units * rate);
      }
}

class DomesticPlan extends Plan {
      // @override
      public void getRate() {
            rate = 3.50;
      }
}

class CommercialPlan extends Plan {
      // @override
      public void getRate() {
            rate = 7.50;
      }
}

class InstitutionalPlan extends Plan {
      // @override
      public void getRate() {
            rate = 5.50;
      }
}

class GetPlanFactory {

      // use getPlan method to get object of type Plan
      public Plan getPlan(String planType) {
            if (planType == null) {
                  return null;
            }
            if (planType.equalsIgnoreCase("DOMESTICPLAN")) {
                  return new DomesticPlan();
            } else if (planType.equalsIgnoreCase("COMMERCIALPLAN")) {
                  return new CommercialPlan();
            } else if (planType.equalsIgnoreCase("INSTITUTIONALPLAN")) {
                  return new InstitutionalPlan();
            }
            return null;
      }
}