这两种模式的意图和应用有什么区别？

Question

Closed. This question needs to be more focused. It is not currently accepting answers.

---

想要改进这个问题吗？通过编辑这篇文章来更新问题，使其仅关注一个问题。

7 年前已关闭。

此帖子已于 12 个月前编辑并提交审核，但未能重新打开帖子：

原始关闭原因未解决

Answer 1

使用工厂模式，您可以生成特定接口的实现实例（Apple、Banana、Cherry 等）——例如，<代码>IFruit。

使用抽象工厂模式，您可以为任何人提供一种提供自己的工厂的方法。 这允许您的仓库是 IFruitFactory 或 IJuiceFactory，而不要求您的仓库了解有关水果或果汁的任何信息。

Answer 2

此信息来源取自：http://java.dzone.com /新闻/intro-design-patterns-abstract

抽象工厂与工厂方法

抽象工厂的方法作为工厂方法实现。 抽象工厂模式和工厂方法模式都通过抽象类型和工厂将客户端系统与实际实现类解耦。
工厂方法通过继承创建对象，而抽象工厂通过组合创建对象。

抽象工厂模式由 AbstractFactory、ConcreteFactory、AbstractProduct、ConcreteProduct 和 Client 组成。

如何实现

抽象工厂模式可以使用工厂方法模式、原型模式或单例模式来实现。 ConcreteFactory 对象可以作为 Singleton 实现，因为只需要 ConcreteFactory 对象的一个​​实例。

工厂方法模式是抽象工厂模式的简化版本。 工厂方法模式负责创建属于一个系列的产品，而抽象工厂模式则处理多个系列的产品。

工厂方法使用接口和抽象类将客户端与生成器类和结果产品解耦。 抽象工厂有一个生成器，它是多个工厂方法的容器，以及将客户端与生成器和产品解耦的接口。

何时使用工厂方法模式

当需要将客户端与其使用的特定产品解耦时，请使用工厂方法模式。 使用工厂方法可以减轻客户创建和配置产品实例的责任。

何时使用抽象工厂模式

当客户端必须与产品类解耦时，请使用抽象工厂模式。
对于程序配置和修改特别有用。 抽象工厂模式还可以强制限制哪些类必须与其他类一起使用。 建造新的混凝土工厂可能需要大量工作。

示例：

Abstract Factory 示例 1

此规范用于准备不同类型面食的磁盘
面条机中的抽象工厂是抽象工厂，每个特定的磁盘都是一个工厂。
所有工厂（面条机磁盘）都从抽象工厂继承其属性。
每个单独的磁盘都包含如何制作意大利面的信息，而意大利面制作机则没有。

抽象工厂示例2：

冲压设备对应于抽象工厂，它是一个
用于创建抽象产品对象的操作的接口。
模具对应于混凝土工厂，因为它们制造混凝土产品。
每个零件类别（引擎盖、门等）都对应于抽象产品。
具体部件（即99凯美瑞的驾驶员侧车门）对应于
混凝土产品。

工厂方法示例：

玩具公司对应于创建者，因为它可以使用工厂来创建产品对象。 生产特定类型玩具（马或汽车）的玩具公司的部门对应于 ConcreteCreator。

Answer 3

工厂模式：
工厂生产 IProduct-implementations

抽象工厂模式：
工厂-工厂生产 IFactories，进而生产 IProducts :)

[根据评论更新]
至少根据维基百科，我之前写的内容是不正确的。 抽象工厂只是一个工厂接口。 有了它，您可以在运行时切换工厂，以允许不同上下文中的不同工厂。 例如，不同操作系统的不同工厂、SQL 提供程序、中间件驱动程序等。

Answer 4

抽象工厂模式

• 提供用于创建的接口
  有亲属关系或受抚养人的家庭
  对象而不指定它们的
  具体类。

• 抽象工厂模式非常
  类似于工厂方法
  图案。 之间的一处区别是
  二是抽象工厂
  模式，一个类委托
  对象的责任
  通过实例化到另一个对象
  组成而工厂
  方法模式使用继承和
  依赖子类来处理
  所需的对象实例化。

• 实际上，委托对象
  经常使用工厂方法
  执行实例化！

工厂模式

• 工厂模式的例子
  创作模式

• 创造模式抽象了
  对象实例化过程。 他们
  隐藏对象的创建方式和帮助
  使整个系统独立
  它的对象是如何创建的以及
  组成。

• 类创建模式重点关注
  使用继承来决定
  要实例化的对象
  工厂方法

• 对象创建模式重点关注
  实例化的委托
  到另一个对象
  抽象工厂

参考：
工厂与抽象工厂

Answer 5

基本区别：

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

工厂方法：定义一个用于创建对象的接口，但让子类决定实例化哪个类。

抽象工厂：提供用于创建相关对象系列的接口

AbstractFactory模式使用组合来委托对象创建的责任。

工厂方法模式使用继承并为派生类创建对象

示例：StaticFactory

 public class VehicleFactory {

   //Vehicle factory
   public static Vehicle getVehicle(String type){
      if(type == null){
         return null;
      }     
      if(type.equalsIgnoreCase("Car")){
         return new Car();
         
      } else if(type.equalsIgnoreCase("Truck")){
         return new Truck();
         
      } else if(type.equalsIgnoreCase("Bicycle")){
         return new Bicycle();
      }
      
      return null;
   }
}

何时使用：客户端只需要一个类并且不关心它正在得到哪个具体的实现。

工厂方法

何时使用： 客户端不知道在运行时需要创建哪些具体类，而只是想获得一个可以完成这项工作的类。

抽象工厂

何时使用：当您的系统必须在不公开实现细节的情况下创建多个产品系列时。

Answer 6

工厂方法：你有一个工厂，它创建从特定基类派生的对象

抽象工厂：你有一个工厂，它创建其他工厂，这些工厂又创建从基类派生的对象。 这样做是因为您通常不仅仅想创建单个对象（与工厂方法一样） - 相反，您想创建相关对象的集合。

Answer 7

抽象工厂是用于创建相关对象的接口，而工厂方法是一种方法。 抽象工厂是通过工厂方法来实现的。

Answer 8

也许很多人会感到惊讶，但这个问题是不正确的。 如果你在面试中听到这个问题，你需要帮助面试官理解困惑在哪里。

让我们从以下事实开始：不存在仅称为“工厂”的具体模式。 有一种模式称为“抽象工厂”，也有一种模式称为“工厂方法”。

那么，“工厂”是什么意思呢？ 以下之一（所有都可以被认为是正确的，具体取决于参考的范围）：

• 有些人将其用作“抽象工厂”。
• 有些人将其用作“工厂方法”的别名（快捷方式）。
• 有些人将其用作所有工厂/创建模式的更通用名称。 例如“抽象工厂”和“工厂方法”都是工厂。

而且，不幸的是，许多人使用“工厂”来表示另一种工厂，它创建一个或多个工厂（或其接口）。 根据他们的理论：

Product 实现了 IProduct，它是由 Factory 创建的，
实现 IFactory，它是由 AbstractFactory 创建的。

为了理解这是多么愚蠢，让我们继续我们的方程：

AbstractFactory 实现了 IAbstractFactory，它是由...创建的
抽象抽象工厂？？？

我希望你明白这一点。 不要感到困惑，也请不要发明一些不存在的东西。

-

PS：产品工厂是 AbstractFactory，抽象工厂工厂也是 AbstractFactory 的另一个例子。

Answer 9

抽象工厂的示例/场景

我住在一个雨季下雨、冬天下雪、夏天炎热晴朗的地方。 我需要不同类型的衣服来保护自己免受恶劣天气的影响。 为此，我会去我家附近的商店购买衣服/物品来保护自己。 店主根据环境和我的口袋深度给我合适的物品。 他给我的物品具有相同的质量水平和价格范围。 因为他知道我的标准，所以他很容易做到这一点。 但当街对面的一个有钱人提出同样的要求时，他会得到一件昂贵的品牌商品。 值得注意的一件事是他给我的所有物品在质量、标准和成本方面都是互补的。 可以说他们是相伴而行的。 这位有钱人得到的物品也是如此。

看到上面的场景，我现在体会到店主的办事效率了。 我可以用抽象商店代替这个店主。 我们通过抽象项目获得的项目以及我和作为潜在客户的富人。 我们所需要的只是适合我们需求的产品/项目。

现在，我可以很容易地想到自己正在考虑开设一家为其众多客户提供一系列服务的在线商店。 每个客户都属于三个组之一。 当高级组用户打开该网站时，他会获得出色的用户界面、高度定制的广告窗格、菜单中的更多选项等。这些相同的功能集会呈现给黄金用户，但菜单中的功能较少，广告大多是相关的，以及稍微不那么经济的用户界面。 最后是我的用户类型，“自由组”用户。 我得到了足够的服务，这样我就不会被冒犯。 用户界面是最低限度的，广告太偏离轨道了，我不知道里面有什么，最后菜单只能退出。

如果我有机会建立像这个网站这样的东西，我肯定会考虑抽象工厂模式。

抽象产品：广告窗格、菜单、UI 画家。
抽象工厂：网上商店用户体验
Concreate Factory：高级用户体验、金牌用户体验、一般用户体验。

Answer 10

//Abstract factory - Provides interface to create factory of related products
interface PizzaIngredientsFactory{    
   public Dough createDough(); //Will return you family of Dough
   public Clam createClam();   //Will return you family of Clam
   public Sauce createSauce(); //Will return you family of Sauce
}

class NYPizzaIngredientsFactory implements PizzaIngredientsFactory{

   @Override
   public Dough createDough(){
      //create the concrete dough instance that NY uses
      return doughInstance;
   }

   //override other methods
} 

其他答案已经提供了教科书的定义。 我想我也可以提供一个例子。

因此，这里的 PizzaIngredientsFactory 是一个抽象工厂，因为它提供了创建相关产品系列的方法。

请注意，抽象工厂中的每个方法本身就是一个工厂方法。 createDough() 本身就是一个工厂方法，其具体实现将由 NYPizzaIngrdientsFactory 等子类提供。 因此，使用这个每个不同的位置都可以创建属于其位置的具体成分的实例。

工厂方法

提供具体实现实例

示例中：
- createDough() - 提供面团的具体实现。 所以这是一个工厂方法

Abstract Factory

提供接口来创建相关对象系列

在示例中：
- PizzaIngredientsFactory 是一个抽象工厂，因为它允许创建一组相关的对象，例如 Dough、Clams、Sauce 。 为了创建每个对象系列，它提供了一个工厂方法。

Head First 设计模式 中的示例

Answer 11

通过定义我们可以看出两者的区别：

工厂：接口用于创建对象，但子类决定实例化哪个类。 对象的创建是在需要时完成的。

抽象工厂：抽象工厂模式充当创建其他工厂的超级工厂。 在抽象工厂模式中，接口负责创建一组相关对象或依赖对象，而不指定它们的具体类。

因此，在上面的定义中，我们可以强调一个特定的差异。 即工厂模式负责创建对象，抽象工厂负责创建一组相关的对象； 显然都是通过一个接口。

工厂模式：

public interface IFactory{
  void VehicleType(string n);
 }

 public class Scooter : IFactory{
  public void VehicleType(string n){
   Console.WriteLine("Vehicle type: " + n);
  }
 }

 public class Bike : IFactory{
  public void VehicleType(string n) {
  Console.WriteLine("Vehicle type: " + n);
  }
 }

 public interface IVehicleFactory{
  IFactory GetVehicleType(string Vehicle);
 }

 public class ConcreteVehicleFactory : IVehicleFactory{
 public IFactory GetVehicleType(string Vehicle){
   switch (Vehicle){
    case "Scooter":
     return new Scooter();
    case "Bike":
     return new Bike();
    default:
    return new Scooter();
  }
 }

 class Program{
  static void Main(string[] args){
   IVehicleFactory factory = new ConcreteVehicleFactory();
   IFactory scooter = factory.GetVehicleType("Scooter");
   scooter.VehicleType("Scooter");

   IFactory bike = factory.GetVehicleType("Bike");
   bike.VehicleType("Bike");

   Console.ReadKey();
 }
}

抽象工厂模式：

interface IVehicleFactory{
 IBike GetBike();
 IScooter GetScooter();
}

class HondaFactory : IVehicleFactory{
     public IBike GetBike(){
            return new FZS();
     }
     public IScooter GetScooter(){
            return new FZscooter();
     }
 }
class HeroFactory: IVehicleFactory{
      public IBike GetBike(){
            return new Pulsur();
     }
      public IScooter GetScooter(){
            return new PulsurScooter();
     }
}

interface IBike
    {
        string Name();
    }
interface IScooter
    {
        string Name();
    }

class FZS:IBike{
   public string Name(){
     return "FZS";
   }
}
class Pulsur:IBike{
   public string Name(){
     return "Pulsur";
   }
}

class FZscooter:IScooter {
  public string Name(){
     return "FZscooter";
   }
}

class PulsurScooter:IScooter{
  public string Name(){
     return "PulsurScooter";
   }
}

enum MANUFACTURERS
{
    HONDA,
    HERO
}

class VehicleTypeCheck{
        IBike bike;
        IScooter scooter;
        IVehicleFactory factory;
        MANUFACTURERS manu;

        public VehicleTypeCheck(MANUFACTURERS m){
            manu = m;
        }

        public void CheckProducts()
        {
            switch (manu){
                case MANUFACTURERS.HONDA:
                    factory = new HondaFactory();
                    break;
                case MANUFACTURERS.HERO:
                    factory = new HeroFactory();
                    break;
            }

      Console.WriteLine("Bike: " + factory.GetBike().Name() + "\nScooter: " +      factory.GetScooter().Name());
        }
  }

class Program
    {
        static void Main(string[] args)
        {
            VehicleTypeCheck chk = new VehicleTypeCheck(MANUFACTURERS.HONDA);
            chk.CheckProducts();

            chk= new VehicleTypeCheck(MANUFACTURERS.HERO);
            chk.CheckProducts();

            Console.Read();
        }
    }

Answer 12

我对约翰的回答有一些看法，如下：

抽象工厂是工厂的工厂！

使用“工厂方法”（因为“工厂”是不明确的），您可以生成特定接口的实现（Lemon、Orange 等）——例如，<代码>IFruit。 该工厂可以称为CitricFruitFactory。

但现在您想要创建 CitricFruitFactory 无法创建的另一种水果。 如果您在其中创建一个 Strawberry ，则 CitricFruitFactory 的代码可能没有意义（草莓不是柠檬酸水果！）。

因此，您可以创建一个名为 RedFruitFactory 的新工厂，用于生产 Strawberry、Raspberry 等。

就像 John Feminella 所说：
知道如何创建不同种类的水果。”

“使用抽象工厂模式，您可以生成特定工厂接口的实现 - 例如，IFruitFactory。其中每一个都 IFruitFactory 是 CitricFruitFactory 和 RedFruitFactory！

Answer 13

我的来源是：StackOverflow、tutorialspoint.com、programmers.stackexchange.com 和 CodeProject.com。

---

Factory Method（也称为Factory）用于解耦Interface实现的客户端。 例如，我们有一个 Shape 接口，其中有两个 Circle 和 Square 实现。 我们定义了一个带有工厂方法的工厂类，该方法带有确定参数（例如 Type）以及 Shape 接口的新相关实现。

---

Abstract Factory 包含多个工厂方法或由多个工厂实现组成的工厂接口。
对于上面的下一个示例，我们有一个 Color 接口，其中包含两个 Red 和 Yellow 实现。
我们定义了一个 ShapeColorFactory 接口，其中包含两个 RedCircleFactory 和 YellowSquareFactory。 下面的代码解释了这个概念：

interface ShapeColorFactory
{
    public Shape getShape();
    public Color getColor();
}

class RedCircleFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Circle();
    }

    @Override
    public Color getColor() {
        return new Red();
    }
}
class YellowSquareFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Square();
    }

    @Override
    public Color getColor() {
        return new Yellow();
    }
} 

这是FactoryMethod和AbstractFactory之间的区别。 工厂方法简单地返回接口的具体类，但抽象工厂返回工厂的工厂。 换句话说，抽象工厂返回一系列接口的不同组合。

---

我希望我的解释有用。

Answer 14

这些工厂的主要区别在于您何时想要对工厂做什么以及何时想要使用它。

有时，当您进行 IOC（控制反转，例如构造函数注入）时，您知道可以创建实体对象。 正如上面的水果示例中提到的，如果您准备创建水果对象，则可以使用简单的工厂模式。

但很多时候，您不想创建实体对象，它们稍后会出现在程序流程中。 但是配置会告诉您要在开始时使用哪种工厂，您可以将从公共工厂类派生的工厂传递给 IOC 中的构造函数，而不是创建对象。

所以，我认为这也与对象的生命周期和创建有关。

Answer 15

扩展 John Feminella 的答案：

Apple、Banana、Cherry 实现了 FruitFactory 并且具有一个名为 Create 的方法，它单独负责创建 Apple、Banana 或 Cherry。 您的 Factory 方法就完成了。

现在，您想用水果创建一种特殊的沙拉，您的抽象工厂就出现了。 Abstract Factory 知道如何用苹果、香蕉和樱桃制作您的特色沙拉。

public class Apple implements Fruit, FruitFactory {
    public Fruit Create() {
        // Apple creation logic goes here
    }
}

public class Banana implements Fruit, FruitFactory {
    public Fruit Create() {
        // Banana creation logic goes here
    }
}

public class Cherry implements Fruit, FruitFactory {
    public Fruit Create() {
        // Cherry creation logic goes here
    }
}

public class SpecialSalad implements Salad, SaladFactory {
    public static Salad Create(FruitFactory[] fruits) {
        // loop through the factory and create the fruits.
        // then you're ready to cut and slice your fruits 
        // to create your special salad.
    }
}

Answer 16

工厂方法和抽象工厂都使客户端与具体类型解耦。 两者都创建对象，但 Factory 方法使用继承，而 Abstract Factory 使用组合。

工厂方法在子类中继承以创建具体对象（产品），而抽象工厂提供用于创建相关产品系列的接口，这些接口的子类定义如何创建相关产品。

然后，这些子类在实例化时被传递到产品类中，并在其中用作抽象类型。 抽象工厂中的相关产品通常使用工厂方法来实现。

Answer 17

检查此处：http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm
工厂方法似乎使用特定的类（非抽象）作为基类，而抽象工厂为此使用抽象类。 此外，如果使用接口而不是抽象类，结果将是抽象工厂模式的不同实现。

：D

Answer 18

抽象工厂是用于创建不同类型接口的模板。
假设您的项目要求您解析不同类型的 csv 文件，其中包含数量、价格和项目特定信息，例如某些包含有关水果的数据，其他有关巧克力的数据，然后在解析后，您需要在相应的数据库中更新此信息，这样现在您就可以拥有一个抽象工厂返回解析器和修饰符工厂，然后这个解析器工厂可以返回巧克力解析器对象、水果解析器对象等，类似地修改器工厂可以返回巧克力修饰符对象、水果修饰符对象等。

Answer 19

我认为我们可以通过查看 Java8 示例代码来理解这两者之间的区别：

  interface Something{}

  interface OneWhoCanProvideSomething {
     Something getSomething();
  }

  interface OneWhoCanProvideCreatorsOfSomething{
     OneWhoCanProvideSomething getCreator();
  }


public class AbstractFactoryExample {

    public static void main(String[] args) {
        //I need something
        //Let's create one
        Something something = new Something() {};

        //Or ask someone (FACTORY pattern)
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeA = () -> null;
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeB = () -> null;

        //Or ask someone who knows soemone who can create something (ABSTRACT FACTORY pattern)
        OneWhoCanProvideCreatorsOfSomething oneWhoCanProvideCreatorsOfSomething = () -> null;

        //Same thing, but you don't need to write you own interfaces
        Supplier<Something> supplierOfSomething = () -> null;
        Supplier<Supplier<Something>> supplierOfSupplier = () -> null;
    }

}

现在的问题是您应该使用哪种创建方式以及为什么：
第一种方法（没有模式，只是简单的构造函数）：自己创建不是一个好主意，您必须完成所有工作，并且您的客户端代码与特定实现相关联。

第二种方式（使用工厂模式）：为您提供可以传递任何类型的实现的好处，它可以根据某些条件（可能是传递给创建方法的参数）提供不同类型的东西。

第三种方式（使用抽象工厂模式）：这为您提供了更大的灵活性。 您可以根据某些条件（可能是传递的参数）找到某物的不同类型的创建者。

请注意，您总是可以通过将两个条件组合在一起来摆脱工厂模式（这会稍微增加代码复杂性和耦合性），我想这就是为什么我们很少看到抽象工厂模式的现实用例。