我知道有很多关于这两种模式之间区别的帖子，但是有一些东西我找不到。
从我所阅读的内容来看，工厂方法模式允许您定义如何创建单个具体产品，但将实现隐藏在客户端外，因为他们将看到通用产品。我的第一个问题是关于抽象工厂的。它的作用是允许您创建依赖于您使用的特定工厂的多组具体对象，而不仅仅是单个具体对象吗？抽象工厂只返回一个非常大的对象还是许多对象，取决于您调用的方法?
我最后的两个问题都涉及到我无法完全理解的一个引号，在许多地方看到：
两者之间的一个区别是，使用抽象工厂模式，通过组合，类将对象实例化的责任委派给另一个对象，而工厂方法模式使用继承并依赖于子类来处理所需的对象实例化。
我的理解是，工厂方法模式具有一个Creator接口，使ConcreteCreator负责知道要实例化哪个ConcreteProduct。这就是它使用继承处理对象实例化的含义吗？
现在就那个引号而言，抽象工厂模式如何通过组合将对象实例化的责任委托给另一个对象？这是什么意思？在我看来，抽象工厂模式也使用继承来执行构建过程，但我仍在学习这些模式。
特别是对于最后一个问题的任何帮助，将不胜感激。
"工厂方法"和"抽象工厂"的主要区别在于，工厂方法是一个方法，而抽象工厂是一个对象。很多人混淆这两个术语，并开始交替使用它们。我记得当我学习它们时，我很难找到确切的区别。
因为工厂方法只是一个方法，它可以在子类中被重写，因此您引用的后半部分说：
... 工厂模式使用继承并依赖子类来处理所需的对象实例化。
引用假定一个对象在这里调用了它自己的工厂方法。因此，唯一能够改变返回值的是子类。
抽象工厂是一个具有多个工厂方法的对象。看看你引用的第一部分：
... 在抽象工厂模式中，一个类通过组合将对象实例化的责任委托给另一个对象 ...
他们的意思是有一个对象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
makeFoo 实现演示了这一点。 - Tom Dalling抽象工厂创建一个基类并定义了创建对象的抽象方法。派生自基类的每个工厂类都可以为每种对象类型创建自己的实现。
工厂方法是一个简单的方法，用于在类中创建对象。通常将其添加到聚合根（例如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（里氏替换原则）。
Button() 来制作“相关产品族”。例如，经典的 GoF 示例创建了 ScrollBar() 和 Window()。优点是抽象工厂可以在其多个产品之间执行通用主题。 - jaco0646
抽象工厂模式实现：
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()。这就是为什么我们说工厂方法是通过继承来实现的。Creator（父类）调用自己的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》中提出的静态工厂模式。《Head First 设计模式》一书包括了另一种他们称之为简单工厂的模式。
不要陷入认为每个工厂模式都必须与GoF中的一个匹配的陷阱中。
factoryMethod()方法是否应该始终是protected方法？（我认为是的） - Yaroslav Fedorukpublic工厂方法，而且该方法甚至不需要是abstract的；但是关键点在于该方法用于继承，因此它不能（例如）是static或final。我将该方法设置为protected和abstract，以突出显示（必需的）可扩展性。 - jaco0646抽象工厂是一个用于创建相关产品的接口，但工厂方法只是其中的一种方法。抽象工厂可以通过多个工厂方法来实现。
考虑以下示例以便更好理解。
电信公司提供什么？例如宽带、电话线和移动服务，您被要求创建一个应用程序来向他们的客户提供这些产品。
通常情况下，您需要通过工厂方法创建产品，如宽带、电话线和移动服务。你知道这些产品的属性，并且这样做非常简单明了。
现在，公司想要为客户提供一组捆绑销售的产品，例如宽带、电话线和移动服务，这时就可以使用抽象工厂了。
抽象工厂是其他工厂的组合，它们各自负责创建自己的产品。在此过程中，抽象工厂知道如何将这些产品放置在更有意义的位置上，从而履行自己的职责。
在这种情况下，BundleFactory是抽象工厂，BroadbandFactory、PhonelineFactory和MobileFactory是工厂。更简单地说，这些工厂将具有工厂方法来初始化各个产品。
请参见下面的代码示例：
public class BroadbandFactory : IFactory {
public static Broadband CreateStandardInstance() {
// broadband product creation logic goes here
}
}
public class PhonelineFactory : IFactory {
public static Phoneline CreateStandardInstance() {
// phoneline product creation logic goes here
}
}
public class MobileFactory : IFactory {
public static Mobile CreateStandardInstance() {
// mobile product creation logic goes here
}
}
public class BundleFactory : IAbstractFactory {
public static Bundle CreateBundle() {
broadband = BroadbandFactory.CreateStandardInstance();
phoneline = PhonelineFactory.CreateStandardInstance();
mobile = MobileFactory.CreateStandardInstance();
applySomeDiscountOrWhatever(broadband, phoneline, mobile);
}
private static void applySomeDiscountOrWhatever(Broadband bb, Phoneline pl, Mobile m) {
// some logic here
// maybe manange some variables and invoke some other methods/services/etc.
}
}
希望这有所帮助。
现实生活中的例子（易于记忆）
工厂
想象一下，你正在建造一座房子，你向木匠要门。你给出门的尺寸和要求，他将为你制作一扇门。在这种情况下，木匠就是门的工厂。你的规格是工厂的输入，门是工厂的输出或产品。
抽象工厂
现在，考虑同样的门的例子。你可以去找木匠，也可以去找塑料门店或PVC门店。所有这些都是门的工厂。根据情况，你决定需要接触哪种类型的工厂。这就像一个抽象工厂。
我在这里解释了工厂方法模式和抽象工厂模式，开始时没有使用它们来解释问题，然后通过使用上述模式来解决问题。 https://github.com/vikramnagineni/Design-Patterns/tree/master
1. 我的第一个问题是关于抽象工厂模式的。它的作用是允许您创建具体对象的家族（可以取决于您使用的特定工厂）而不仅仅是单个具体对象吗？
是的。抽象工厂的意图是：
提供一个接口，用于创建相关或依赖对象的家族，而不需要指定它们的具体类。
2. 抽象工厂只返回一个非常大的对象还是根据调用的方法返回多个对象？
理想情况下，它应该根据客户端调用的方法返回一个对象。
3. 我的理解是，工厂方法模式有一个创建者接口，将具体创建者负责知道要实例化哪个具体产品。这是否意味着使用继承来处理对象实例化？
是的。工厂方法使用继承。
4. 抽象工厂模式通过组合将对象实例化的责任委托给另一个对象？这是什么意思？
AbstractFactory定义了一个FactoryMethod，ConcreteFactory负责构建ConcreteProduct。
只需按照James Sugrue在dzone文章中的代码示例即可。
您可以在相关SE帖子中找到更多详细信息：
有许多定义。通常，描述工厂模式的三种常见方式如下：
一种基于条件的简单对象创建方法/类。
使用子类提供实现的工厂方法设计模式。
抽象工厂设计模式生产相关或依赖对象系列，而不指定它们的具体类。
以下链接非常有用- 工厂比较 - refactoring.guru
