设计模式:工厂vs工厂方法vs抽象工厂

工厂 -分离工厂类来创建复杂的对象。

例如:FruitFactory类来创建Fruit对象

class FruitFactory{


public static Fruit getFruit(){...}


}

工厂方法 -不用为工厂添加一个单独的类，只需在类中添加一个方法作为工厂。

例:

Calendar.getInstance() (Java's Calendar)

抽象工厂 -工厂的工厂

比方说，我们想建一家生产电脑零件的工厂。有几种类型的电脑，如笔记本电脑，台式电脑，服务器。

所以对于每一种计算机类型，我们都需要工厂。所以我们创建了一个高级的工厂中的工厂，如下所示

ComputerTypeAbstractFactory.getComputerPartFactory(String computerType) ---> This will return PartFactory which can be one of these ServerPartFactory, LaptopPartFactory, DesktopPartFactory.

现在这3家公司本身也是工厂。(您将处理PartFactory本身，但在底层，将有基于您在抽象工厂中提供的内容的单独实现)

  Interface-> PartFactory. getComputerPart(String s),
Implementations -> ServerPartFactory, LaptopPartFactory, DesktopPartFactory.


Usage:
new ComputerTypeAbstractFactory().getFactory(“Laptop”).getComputerPart(“RAM”)

EDIT:根据注释中的异议为抽象工厂提供精确的接口。

每个设计模式都努力确保编写的工作代码不受影响。我们都知道，一旦我们接触到工作代码，现有的工作流程中就会有缺陷，并且需要进行更多的测试以确保我们没有破坏任何东西。

工厂模式根据输入条件创建对象，从而确保你不需要编写如下代码:

 if (this) {
create this kind of object
} else {
that kind of object
}

一个很好的例子就是旅游网站。旅游网站只能提供旅行(航班、火车、巴士)或/和提供酒店或/和提供旅游景点套餐。现在，当用户选择下一步时，网站需要决定需要创建什么对象。它是否也只创建travel或hotel对象?

现在，如果你设想在你的投资组合中添加另一个网站，并且你相信同样的核心可以被使用，例如，一个拼车网站，现在可以搜索出租车并在线支付，你可以在你的核心中使用一个抽象工厂。这样一来，你就可以再加入一个出租车和拼车工厂。

这两个工厂之间没有任何关系，所以把它们放在不同的工厂是一个很好的设计。

希望大家都明白了。再次研究这个网站，记住这个例子，希望它会有帮助。我真的希望我已经正确地表示了模式:)。

所有三种工厂类型都做同样的事情:它们是“聪明的构造器”。

假设您希望能够创建两种水果:Apple和Orange。

工厂

class FruitFactory {


public Apple makeApple() {
// Code for creating an Apple here.
}


public Orange makeOrange() {
// Code for creating an orange here.
}


}

用例:在构造函数中构造Apple或Orange都太复杂了。

工厂方法

abstract class FruitPicker {


protected abstract Fruit makeFruit();


public void pickFruit() {
private final Fruit f = makeFruit(); // The fruit we will work on..
<bla bla bla>
}
}

.．.那么你可以通过在子类中实现一个工厂方法来重用FruitPicker.pickFruit()中的公共功能:

class OrangePicker extends FruitPicker {


@Override
protected Fruit makeFruit() {
return new Orange();
}
}

抽象工厂

interface PlantFactory {
  

Plant makePlant();


Picker makePicker();


}


public class AppleFactory implements PlantFactory {
Plant makePlant() {
return new Apple();
}


Picker makePicker() {
return new ApplePicker();
}
}


public class OrangeFactory implements PlantFactory {
Plant makePlant() {
return new Orange();
}


Picker makePicker() {
return new OrangePicker();
}
}

AbstractProductA, A1 and A2 both implementing the AbstractProductA
AbstractProductB, B1 and B2 both implementing the AbstractProductB


interface Factory {
AbstractProductA getProductA(); //Factory Method - generate A1/A2
}

使用工厂方法，用户可以创建AbstractProductA的A1或A2。

interface AbstractFactory {
AbstractProductA getProductA(); //Factory Method
AbstractProductB getProductB(); //Factory Method
}

1. 这三种模式之间有什么不同?

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

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

抽象工厂:提供了一个接口，用于创建相关或依赖的对象族，而不指定它们的具体类。

AbstractFactory模式使用组合将创建对象的责任委托给另一个类，而工厂方法设计模式使用继承并依赖于派生类或子类来创建对象

2. 什么时候用哪个?

工厂:客户端只需要一个类，并不关心它得到的具体实现。

工厂方法:客户端不知道在运行时需要创建什么具体的类，但只是想获得一个将完成这项工作的类。

AbstactFactory:当你的系统必须创建多个产品家族，或者你想提供一个产品库而不暴露实现细节时。

抽象工厂类通常用工厂方法实现。工厂方法通常在模板方法中调用。

3. 如果可能的话，还有与这些模式相关的java示例吗?

Factory和FactoryMethod

< em >目的:< / em >

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

UML图:

产品:它定义Factory方法创建的对象的接口。

实现Product接口

创造者:声明Factory方法

ConcreateCreator:实现Factory方法以返回ConcreteProduct的实例

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

代码片段:

工厂模式。什么时候使用工厂方法?< / >

进一步阅读的参考:Sourcemaking设计模式

要回答这个问题，我可以参考《四人帮》一书。

书中有没有“工厂”或“简单工厂”或“虚拟工厂”的定义。通常当人们谈论“工厂”模式时，他们可能在谈论创建类的特定对象的东西(而不是“建造者”模式);他们可能，也可能不指的是“工厂方法”或“抽象工厂”模式。任何人都可以实现“工厂”，但他不会，因为它不是一个正式的术语(请记住，一些人、公司、社区可以有自己的词汇表)。

本书只有包含了“抽象工厂”和“工厂方法”的定义。

以下是书中的定义，并简要解释了为什么两者都如此令人困惑。我省略了代码示例，因为你可以在其他答案中找到它们:

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

抽象工厂(GOF):提供一个接口来创建相关或依赖的对象族，而不指定它们的具体类。

困惑的根源:通常，可以将“Factory Method”模式中使用的类称为“Factory”。这个类根据定义是抽象的。这就是为什么很容易称这个类为“抽象工厂”。但这只是类的名字;你不应该将它与“抽象工厂”模式(类名!=模式名)混淆。“抽象工厂”模式是不同的-它不使用一个抽象类;它定义了一个接口(不一定是编程语言接口)，用于创建较大对象的各个部分，或者创建相互关联或必须以特定方式创建的对象。

没有人引用原著设计模式:可重用面向对象软件的元素，它在“讨论创造模式”部分的前两段给出了答案(强调我的):