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等，而无需修改现有的体系结构。因此，您遵循了“修改封闭，扩展开放”的原则。

如果你想在使用方面创建一个不同的对象。它很有用。

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;
      }
}

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

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

实现这一点的最简单方法是让每个对象在它们的construct方法上创建它们的子对象，但是如果属性是相对嵌套的，那么当您的House创建失败时，您可能会花一些时间试图隔离到底是什么失败了。

另一种方法是做以下事情(依赖注入，如果你喜欢这个花哨的术语):

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

在这里，如果创建House的过程失败了，那么只有一个地方可以查看，但每次想要一个新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时，您不需要创建和设置每个依赖项)，同时是集中的，这使得它更容易维护。使用单独的工厂是有益的还有其他原因(例如可测试性)，但我发现这个特定的用例最好地说明了工厂类是如何有用的。

在对象中使用工厂方法是个好主意:

对象的类不知道它必须创建什么确切的子类 Object的类被设计成它创建的对象由子类指定 对象的类将其职责委托给辅助子类，并且不知道确切的类将承担这些职责

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

对象不应该依赖于其内部对象是如何创建和设计的 一组链接的对象应该一起使用，您需要满足这个约束 对象应该由几个可能的链接对象家族中的一个来配置，这些对象将成为父对象的一部分 它需要共享只显示接口而不显示实现的子对象

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

工厂方法解耦得很好，但是工厂类不行。

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

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