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

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

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

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

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

该系统采用了多态、依赖注入和控制反转等技术。

Factory Patterns的目的是:定义一个用于创建对象的接口，但是让子类来决定实例化哪个类。工厂方法允许类延迟实例化到子类。

假设你正在构建一个操作系统或框架，你正在构建所有的离散组件。

下面是PHP中工厂模式概念的一个简单示例。我可能不会完全理解，但这只是一个简单的例子。我不是专家。

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

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

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

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

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

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

让我们具体谈谈“工厂方法”:

首先，当您正在开发库或api时，这些库或api将用于进一步的应用程序开发，那么工厂方法是创建模式的最佳选择之一。原因;我们知道什么时候创建一个所需功能的对象，但对象的类型仍未确定，或者将根据传递的动态参数来决定。

Now the point is, approximately same can be achieved by using factory pattern itself but one huge drawback will introduce into the system if factory pattern will be used for above highlighted problem, it is that your logic of crating different objects(sub classes objects) will be specific to some business condition so in future when you need to extend your library's functionality for other platforms(In more technically, you need to add more sub classes of basic interface or abstract class so factory will return those objects also in addition to existing one based on some dynamic parameters) then every time you need to change(extend) the logic of factory class which will be costly operation and not good from design perspective. On the other side, if "factory method" pattern will be used to perform the same thing then you just need to create additional functionality(sub classes) and get it registered dynamically by injection which doesn't require changes in your base code.

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