两者的区别

“工厂方法”与“工厂方法”的主要区别是:而“抽象工厂”;工厂方法是一个方法，而抽象工厂是一个对象。我想很多人都把这两个词搞混了，开始交替使用。我记得当我学习它们的时候，我很难找到它们之间的确切区别。

因为工厂方法只是一个方法，它可以在子类中被重写，因此引用的后半部分:

< p >…工厂方法模式使用的 继承并依赖于一个子类 来处理所需的对象 实例化。< / p >

引用假设这里有一个对象正在调用自己的工厂方法。因此，唯一可以改变返回值的是子类。

抽象工厂是一个具有多个工厂方法的对象。看看你引言的前半部分:

< p >…使用抽象工厂模式，一个类 委托对象的职责 实例化到另一个对象 作文…< / p >

他们说的是，有一个对象A，想要创建一个Foo对象。而不是创建Foo对象本身(例如，使用工厂方法)，它将获得一个不同的对象(抽象工厂)来创建Foo对象。

代码示例

为了向你展示区别，这里有一个正在使用的工厂方法:

class A {
public void doSomething() {
Foo f = makeFoo();
f.whatever();
}


protected Foo makeFoo() {
return new RegularFoo();
}
}


class B extends A {
protected Foo makeFoo() {
//subclass is overriding the factory method
//to return something different
return new SpecialFoo();
}
}

这是一个正在使用的抽象工厂:

class A {
private Factory factory;


public A(Factory factory) {
this.factory = factory;
}


public void doSomething() {
//The concrete class of "f" depends on the concrete class
//of the factory passed into the constructor. If you provide a
//different factory, you get a different Foo object.
Foo f = factory.makeFoo();
f.whatever();
}
}


interface Factory {
Foo makeFoo();
Bar makeBar();
Aycufcn makeAmbiguousYetCommonlyUsedFakeClassName();
}


//need to make concrete factories that implement the "Factory" interface here

抽象工厂创建一个具有抽象方法的基类，为应该创建的对象定义方法。派生基类的每个工厂类都可以创建每种对象类型的自己的实现。

工厂方法只是一个用于在类中创建对象的简单方法。它通常添加在聚合根中(Order类有一个名为CreateOrderLine的方法)

抽象工厂

在下面的示例中，我们设计了一个接口，这样我们就可以将队列创建与消息传递系统分离，因此可以为不同的队列系统创建实现，而不必更改代码库。

interface IMessageQueueFactory
{
IMessageQueue CreateOutboundQueue(string name);
IMessageQueue CreateReplyQueue(string name);
}


public class AzureServiceBusQueueFactory : IMessageQueueFactory
{
IMessageQueue CreateOutboundQueue(string name)
{
//init queue
return new AzureMessageQueue(/*....*/);
}


IMessageQueue CreateReplyQueue(string name)
{
//init response queue
return new AzureResponseMessageQueue(/*....*/);
}


}


public class MsmqFactory : IMessageQueueFactory
{
IMessageQueue CreateOutboundQueue(string name)
{
//init queue
return new MsmqMessageQueue(/*....*/);
}


IMessageQueue CreateReplyQueue(string name)
{
//init response queue
return new MsmqResponseMessageQueue(/*....*/);
}
}

工厂方法

HTTP服务器的问题在于，我们总是需要为每个请求提供响应。

public interface IHttpRequest
{
// .. all other methods ..


IHttpResponse CreateResponse(int httpStatusCode);
}

如果没有工厂方法，HTTP服务器用户(即程序员)将被迫使用特定于实现的类，这就违背了IHttpRequest接口的目的。

因此，我们引入工厂方法，以便响应类的创建也被抽象出来。

总结

区别在于类的目的包含一个工厂方法不是创建对象吗，而抽象工厂应该只用于创建对象。

使用工厂方法时应该小心，因为在创建对象时很容易破坏LSP (利斯科夫替换原理)。

AbstractFactory和Factory设计模式之间的区别如下:

• 工厂方法只用于创建一个产品，而抽象工厂用于创建一系列相关或依赖的产品。
• 工厂方法模式向客户端公开了一个方法来创建对象，而在抽象工厂模式中，它们公开了一系列相关的对象，这些对象可能由这些Factory方法组成。
• 工厂方法模式隐藏单个对象的构造，而抽象工厂模式隐藏一系列相关对象的构造。抽象工厂通常使用(一组)工厂方法来实现。
• 抽象工厂模式使用组合将创建对象的责任委托给另一个类，而工厂方法设计模式使用继承并依赖于派生类或子类来创建对象。
• 工厂方法模式背后的思想是，它允许这样的情况:客户端不知道在运行时需要创建哪些具体的类，但只想获得一个可以完成工作的类，而抽象工厂模式在系统必须创建多个产品系列或您想提供一个产品库而不暴露实现细节时得到最佳利用。

工厂方法模式实现:

抽象工厂模式实现:

抽象工厂是创建相关产品的接口，而工厂方法只是一种方法。抽象工厂可以通过多种工厂方法实现。

让我们明确一点，在生产代码中，大多数时候我们使用抽象工厂模式，因为类A是用接口b编程的，而A需要创建b的实例，因此A必须有一个工厂对象来生成b的实例，因此A不依赖于b的任何具体实例，希望它有帮助。

1. 我的第一个问题是关于抽象工厂。它的角色是否允许您在其中创建一系列具体对象(这取决于您使用的具体工厂)，而不仅仅是单个具体对象?

是的。抽象工厂的目的是:

提供一个接口，用于创建一系列相关或依赖的对象，而无需指定它们的具体类。

2. 根据调用的方法，抽象工厂只返回一个非常大的对象还是多个对象?

# EYZ0

3. 我的理解是，工厂方法模式有一个Creator接口，它将使ConcreteCreator负责知道要实例化哪个ConcreteProduct。这就是使用继承来处理对象实例化的意思吗?

# EYZ0

4. 抽象工厂模式委托对象实例化的责任通过组合到另一个对象?这是什么意思?

# EYZ0 # EYZ1。

你可以在SE的相关文章中找到更多细节:

工厂模式和抽象工厂模式的基本区别是什么?< / >

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

比起工厂方法，我更喜欢抽象工厂。从Tom Dalling上面的例子(顺便说一句，解释得很好)中，我们可以看到抽象工厂是更可组合的，因为我们所需要做的只是将一个不同的工厂传递给构造函数(这里使用构造函数依赖注入)。但是工厂方法要求我们引入一个新类(需要管理更多的东西)并使用子类化。总是选择组合而不是继承。

另一方面，假设您正在编写一个框架，以便许多人可以使用您的框架构建各种工具(比如上面例子中的那个)。根据框架的思想，您不需要这样做，尽管您不能在逻辑中使用具体对象。而是在各种对象之间以及它们如何交互之间放置一些高级契约。当您(作为框架开发人员)仍然停留在非常抽象的级别时，工具的每个构建者都被迫遵循您的框架构造。然而，他们(工具构建者)可以自由地决定构建什么对象以及他们创建的所有对象将如何交互。与之前的情况(抽象工厂模式)不同，您(作为框架创建者)在这种情况下不需要使用具体对象;而是停留在客体的契约层面。此外，与前面动机的第二部分不同，您或工具构建者永远不会遇到混合来自变体的对象的情况。在这里，虽然框架代码仍然处于契约级别，但每个工具构建者都被限制使用他们自己的对象(由案件本身的性质决定)。在这种情况下，对象创建委托给每个实现者，框架提供者只是提供了创建和返回对象的统一方法。这样的方法对于框架开发人员来说是不可避免的，并且有一个特殊的名字叫做工厂方法 (底层模式的工厂方法模式)。< p > # EYZ0 < /强> < p >

//Part of framework-code
BoardGame {
Board createBoard() //factory method. Default implementation can be provided as well
Piece createPiece() //factory method


startGame(){        //template method
Board borad = createBoard()
Piece piece = createPiece()
initState(board, piece)
}
}




//Part of Tool-builder code
Ludo inherits  BoardGame {
Board createBoard(){ //overriding of factory method
//Option A: return new LudoBoard() //Lodu knows object creation
//Option B: return LudoFactory.createBoard() //Lodu asks AbstractFacory
}
….
}


//Part of Tool-builder code
Chess inherits  BoardGame {
Board createBoard(){ //overriding of factory method
//return a Chess board
}
….
}

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

public class Client {
public static void main(String[] args) {
ZooFactory zooFactory = new HerbivoreZooFactory();
Animal animal1 = zooFactory.animal1();
Animal animal2 = zooFactory.animal2();
animal1.sound();
animal2.sound();


System.out.println();


AnimalFactory animalFactory = new CowAnimalFactory();
Animal animal = animalFactory.createAnimal();
animal.sound();
}
}

public interface Animal {
public void sound();
}


public class Cow implements Animal {


@Override
public void sound() {
System.out.println("Cow moos");
}
}


public class Deer implements Animal {


@Override
public void sound() {
System.out.println("Deer grunts");
}


}


public class Hyena implements Animal {


@Override
public void sound() {
System.out.println("Hyena.java");
}


}


public class Lion implements Animal {


@Override
public void sound() {
System.out.println("Lion roars");
}


}

public interface ZooFactory {
Animal animal1();


Animal animal2();
}


public class CarnivoreZooFactory implements ZooFactory {


@Override
public Animal animal1() {
return new Lion();
}


@Override
public Animal animal2() {
return new Hyena();
}


}


public class HerbivoreZooFactory implements ZooFactory {


@Override
public Animal animal1() {
return new Cow();
}


@Override
public Animal animal2() {
return new Deer();
}


}

public interface AnimalFactory {
public Animal createAnimal();
}


public class CowAnimalFactory implements AnimalFactory {


@Override
public Animal createAnimal() {
return new Cow();
}


}


public class DeerAnimalFactory implements AnimalFactory {


@Override
public Animal createAnimal() {
return new Deer();
}


}


public class HyenaAnimalFactory implements AnimalFactory {


@Override
public Animal createAnimal() {
return new Hyena();
}


}


public class LionAnimalFactory implements AnimalFactory {


@Override
public Animal createAnimal() {
return new Lion();
}


}

抽象工厂和工厂方法的主要区别是:抽象工厂是由Composition实现的;但是# EYZ1。

是的，你没有看错:这两种模式之间的主要区别是旧的组合vs继承辩论。

UML图可以在(GoF)书中找到。我想提供代码示例，因为我认为将本文中前两个答案中的示例结合起来会比单独一个答案提供更好的演示。此外，我在类名和方法名中使用了书中的术语。

抽象工厂

这里要掌握的最重要的一点是抽象工厂 将注射放入客户端。这就是为什么我们说抽象 Factory是由Composition实现的。通常是依赖项注入 框架将执行该任务;但框架不是必需的 李DI。< / > 第二个关键点是这里的混凝土工厂是 不是工厂方法实现!工厂的示例代码 方法。 最后，要注意的第三点是之间的关系 产品:在本例中是出站队列和应答队列。一个具体 factory生产Azure队列，另一个MSMQ。GoF指 这种产品关系就像一个“家庭”，这很重要 注意在这种情况下family并不意味着类层次结构

public class Client {
private final AbstractFactory_MessageQueue factory;


public Client(AbstractFactory_MessageQueue factory) {
// The factory creates message queues either for Azure or MSMQ.
// The client does not know which technology is used.
this.factory = factory;
}


public void sendMessage() {
//The client doesn't know whether the OutboundQueue is Azure or MSMQ.
OutboundQueue out = factory.createProductA();
out.sendMessage("Hello Abstract Factory!");
}


public String receiveMessage() {
//The client doesn't know whether the ReplyQueue is Azure or MSMQ.
ReplyQueue in = factory.createProductB();
return in.receiveMessage();
}
}


public interface AbstractFactory_MessageQueue {
OutboundQueue createProductA();
ReplyQueue createProductB();
}


public class ConcreteFactory_Azure implements AbstractFactory_MessageQueue {
@Override
public OutboundQueue createProductA() {
return new AzureMessageQueue();
}


@Override
public ReplyQueue createProductB() {
return new AzureResponseMessageQueue();
}
}


public class ConcreteFactory_Msmq implements AbstractFactory_MessageQueue {
@Override
public OutboundQueue createProductA() {
return new MsmqMessageQueue();
}


@Override
public ReplyQueue createProductB() {
return new MsmqResponseMessageQueue();
}
}

工厂方法

这里要掌握的最重要的一点是ConcreteCreator . # 是客户端。换句话说，客户端是一个子类，其父类定义了factoryMethod()。这就是为什么我们这么说 工厂方法由继承实现 第二个关键点是要记住Factory Method 模式只不过是模板方法的专门化 模式。这两种模式共享相同的结构。他们只 目的不同。工厂方法是创造性的(它构建 而模板方法是行为的(它计算 李的东西)。< / > 最后，要注意的第三点是Creator (parent) 类调用它自己的factoryMethod()。如果我们移除 从父类中删除anOperation()，只留下一个方法 在后面，它不再是工厂方法模式。换句话说， 中少于两个方法不能实现工厂方法 父类;其中一个必须调用另一个

public abstract class Creator {
public void anOperation() {
Product p = factoryMethod();
p.whatever();
}


protected abstract Product factoryMethod();
}


public class ConcreteCreator extends Creator {
@Override
protected Product factoryMethod() {
return new ConcreteProduct();
}
}

混杂。,杂项工厂图案

请注意，尽管GoF定义了两种不同的工厂模式，但它们并不是唯一存在的工厂模式。它们甚至不一定是最常用的工厂模式。第三个著名的例子是Josh Bloch的《Effective Java》中的静态工厂模式。《头部优先设计模式》一书还包括另一种被称为简单工厂的模式。

不要落入假设每个工厂模式都必须匹配GoF中的一个模式的陷阱。

工厂方法依赖于继承:对象创建被委托给子类，子类实现了创建对象的工厂方法。

< em >抽象工厂< / em >依赖于对象组合:对象创建在工厂接口中公开的方法中实现。

工厂和抽象工厂模式的高级图表，

有关Factory方法的更多信息，请参阅这篇文章。

有关抽象工厂方法的更多信息，请参阅这篇文章。

抽象工厂:一个工厂的工厂;将独立但相关/依赖的工厂分组在一起，而不指定它们的具体类的工厂。 # EYZ0 < / p >

工厂:它提供了一种将实例化逻辑委托给子类的方法。 # EYZ0 < / p >

有相当多的定义。基本上，描述< >强工厂模式< / >强的三种常见方式是

1. 简单的工厂

基于条件的简单对象创建方法/类。

2. 工厂方法

使用子类提供实现的工厂方法设计模式。

3. 抽象工厂

抽象工厂设计模式产生相关或依赖的对象族，而不指定它们的具体类。

下面的链接非常有用——工厂比较- refactoring.guru

工厂设计模式

generation 1 <- generation 2 <- generation 3
//example
(generation 1) shape <- (generation 2) rectangle, oval <- (generation 3) rectangle impressionism, rectangle surrealism, oval impressionism, oval surrealism

工厂

用例:实例化generation 2的一个对象

它是一个Creational模式，允许您在一个简单的地方创建generation 2。它符合SRP和OCP -所有的更改都在一个类中进行。

enum ShapeType {
RECTANGLE,
OVAL
}


class Shape {}


//Concrete Products
//generation 2
class Rectangle extends Shape {}
class Oval extends Shape {}


//Factory
class Factory {
Shape createShape(ShapeType type) {


switch (type) {
case RECTANGLE:
return new Rectangle();
case OVAL:
return new Oval();
}
}
}


//Creator
class Painter {


private Factory factory;


Painter(Factory factory) {
this.factory = factory;
}


Shape prepareShape(ShapeType type) {
return factory.createShape(type);
}
}


//using
class Main {
void main() {
Painter painter = new Painter(new Factory());


Shape shape1 = painter.prepareShape(ShapeType.RECTANGLE);
Shape shape2 = painter.prepareShape(ShapeType.OVAL);
}
}

工厂方法

用例:实例化generation 3的一个对象

有助于与下一代家庭成员合作。每个画家都有自己的风格，印象派、超现实主义……Factory Method使用抽象的Creator作为工厂(抽象方法)，Concrete Creators是该方法的实现

enum ShapeType {
RECTANGLE,
OVAL
}


class Shape {}


//Concrete Products
//generation 2
class Rectangle extends Shape {}
class Oval extends Shape {}


//generation 3
class RectangleImpressionism extends Rectangle {}
class OvalImpressionism extends Oval {}
class RectangleSurrealism extends Rectangle {}
class OvalSurrealism extends Oval {}


//Creator
abstract class Painter {


Shape prepareShape(ShapeType type) {
return createShape(type);
}


//Factory method
abstract Shape createShape(ShapeType type);
}


//Concrete Creators
class PainterImpressionism {


@override
Shape createShape(ShapeType type) {
switch (type) {
case RECTANGLE:
return new RectangleImpressionism();
case OVAL:
return new OvalImpressionism();
}
}
}


class PainterSurrealism {


@override
Shape createShape(ShapeType type) {
switch (type) {
case RECTANGLE:
return new RectangleSurrealism();
case OVAL:
return new OvalSurrealism();
}
}
}


//using
class Main {
void main() {
Painter painterImpressionism = new PainterImpressionism();
Shape shape1 = painterImpressionism.prepareShape(ShapeType.RECTANGLE);


Painter painterSurrealism = new PainterSurrealism();
Shape shape2 = painterSurrealism.prepareShape(ShapeType.RECTANGLE);
}
}

抽象工厂

用例:实例化generation 3的所有对象

Factory是抽象Factory和实现Concrete Factories的一部分

//Concrete Products
//generation 2
class Rectangle extends Shape {}
class Oval extends Shape {}


//generation 3
class RectangleImpressionism extends Rectangle {}
class OvalImpressionism extends Oval {}
class RectangleSurrealism extends Rectangle {}
class OvalSurrealism extends Oval {}


//Abstract Factory
interface Factory {
Rectangle createRectangle();
Oval createOval();
}


//Concrete Factories
class ImpressionismFactory implements Factory {
@Override
public Rectangle createRectangle() {
return new RectangleImpressionism();
}


@Override
public Oval createOval() {
return new OvalImpressionism();
}
}


class SurrealismFactory implements Factory {
@Override
public Rectangle createRectangle() {
return new RectangleSurrealism();
}


@Override
public Oval createOval() {
return new OvalSurrealism();
}
}


//Creator
class Painter {


Rectangle rectangle;
Oval oval;


Painter(Factory factory) {
rectangle = factory.createRectangle();
rectangle.resize();


oval = factory.createOval();
oval.resize();
}
}


//using
class Main {
void main() {
Painter painter1 = new Painter(new ImpressionismFactory());
Shape shape1 = painter1.rectangle;
Shape shape2 = painter1.oval;


Painter painter2 = new Painter(new ImpressionismFactory());
Shape shape3 = painter2.rectangle;
Shape shape4 = painter1.oval;
}
}

A)工厂方法模式

工厂方法是一种创建设计模式，它提供了创建对象的接口，但允许子类改变将要创建的对象的类型。

如果在基类和扩展它的子类中有一个创建方法，您可能会考虑工厂方法。

B)抽象工厂模式

抽象工厂是一种创造性的设计模式，允许在不指定具体类的情况下产生相关或依赖的对象族。

什么是“对象族”?例如，以这组类为例:传输+引擎+控制。这些可能有几种变体:

1-汽车+内燃机+方向盘

2-平面+ JetEngine +轭

如果你的程序不使用产品族，那么你就不需要抽象工厂。

同样，很多人混淆了抽象工厂模式和简单的工厂类声明为抽象。不要那样做!

裁判:# EYZ0

据我估计，@TomDalling给出的答案确实是正确的(不管它有什么价值)，但是评论中似乎仍然有很多困惑。

我在这里所做的是为这两种模式创建一些略显非典型的示例，并试图使它们乍一看非常相似。这将有助于查明将它们分开的关键差异。

# EYZ0 # EYZ1

如果您对这些模式完全不熟悉，那么这些示例可能不是最好的开始。

工厂方法

Client.javaish

Client(Creator creator) {
ProductA a = creator.createProductA();
}

Creator.javaish

Creator() {}


void creatorStuff() {
ProductA a = createProductA();
a.doSomething();
ProductB b = createProductB();
b.doStuff();
}


abstract ProductA createProductA();


ProductB createProductB() {
return new ProductB1();
}

为什么有Creator和Client?

为什么不呢?FactoryMethod可以与两者一起使用，但是Creator的类型将决定所创建的特定产品。

为什么createProductB在Creator中不是抽象的?

可以提供默认实现，子类仍然可以覆盖该方法以提供自己的实现。

我以为工厂方法只生产一种产品?

每个方法只返回一个产品，但创建者可以使用多个工厂方法，只是它们不一定以任何特定的方式相关。

抽象工厂

Client.javaish

AbstractFactory factory;


Client() {
if (MONDAY) {
factory = new Factory2();
} else {
factory = new AbstractFactory();
}
}


void clientStuff() {
ProductA a = factory.createProductA();
a.doSomething();
ProductB b = factory.createProductB();
b.doStuff();
}

等等!你的AbstractFactory不是，嗯……er # EYZ1

没关系，我们仍然提供接口。创建方法是上的返回类型是我们想要制作的产品的超类型。

圣烟蝙蝠侠!Factory2没有覆盖createProductA()，“产品族”发生了什么?

模式中并没有说一个对象不能属于一个以上的家族(尽管您的用例可能禁止这样做)。每个混凝土工厂负责决定哪些产品可以一起生产。

这是不对的，Client没有使用依赖注入

你必须决定你的具体类将在某个地方，Client仍然被写入AbstractFactory接口。

这里的困惑是人们把作文和依赖注入混为一谈。Client有一个AbstractFactory，不管它是怎么得到的。与IS-A关系相比，Client和AbstractFactory之间没有继承关系。

关键的不同点

• 抽象工厂总是关于对象的家族
• 工厂方法只是允许子类化的一个方法，用于指定具体对象的类型
• 抽象工厂为客户端提供了一个接口，它与产品的使用位置是分开的，工厂方法可以由创建者自己使用，也可以暴露给客户端。

总结

工厂的目的是为客户端或工厂本身提供对象。

创建者有自己的职责，可能需要使用对象或将对象传递给客户端

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

抽象工厂:

提供一个接口来创建相关或依赖的对象族，而不指定它们的具体类。——GoF

PlantUML代码，如果你想玩图:

@startuml FactoryMethod
abstract class Creator {
creatorStuff()
{abstract} createProductA(): ProductA
createProductB(): ProductB
}
class Creator1 {
createProductA(): ProductA
}
class Creator2 {
createProductA(): ProductA
createProductB(): ProductB
}


together {
interface ProductA {
doSomething()
}
class ProductA1
' class Product1B
}
together {
interface ProductB {
doStuff()
}
class ProductB1
class ProductB2
}
Client --> Creator


Creator <|-- Creator1
Creator <|-- Creator2


Creator --> ProductB1
ProductA1 <-- Creator1
ProductA1 <-- Creator2
ProductB2 <-- Creator2


ProductA <|.. ProductA1
ProductB <|.. ProductB1
ProductB <|.. ProductB2


ProductA <- Creator


@enduml

@startuml AbstractFactory


together {
interface ProductA {
doSomething()
}
class ProductA1
}


together {
interface ProductB {
doStuff()
}
class ProductB1
class ProductB2
}


class AbstractFactory {
createProductA(): ProductA
createProductB(): ProductB
--
-
}


class Factory2 {
createProductB(): ProductB
}


Client --> AbstractFactory
AbstractFactory <|-- Factory2


ProductA <|.. ProductA1
ProductB <|.. ProductB1
ProductB <|.. ProductB2


AbstractFactory --> ProductA1
AbstractFactory --> ProductB1
ProductB2 <-- Factory2


@enduml

我的结论:没有区别。为什么?因为我看不出有任何理由为工厂以外的对象配备工厂方法——否则就违反了责任分离原则。此外，我看不出具有单一工厂方法的工厂和具有多个工厂方法的工厂之间有任何区别:两者都创建“相关对象的家族”。除非有人能证明只有一个家庭成员的家庭不是一个家庭。或者包含单个项的集合不是集合。