工厂模式和抽象工厂模式之间的基本区别是什么？

同工厂模式，你生产实现的实例（Apple，Banana，Cherry特定的接口等） -比如，IFruit。

使用抽象工厂模式，您可以为任何人提供自己的工厂的方式。这使您的仓库可以是IFruitFactory或IJuiceFactory，而无需您的仓库了解任何有关水果或果汁的知识。

此信息的来源来自：http : //java.dzone.com/news/intro-design-patterns-abstract

抽象工厂与工厂方法

抽象工厂的方法被实现为工厂方法。抽象工厂模式和工厂方法模式都通过抽象类型和工厂使客户端系统与实际的实现类脱钩。工厂方法通过继承创建对象，而抽象工厂通过合成创建对象。

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

如何实施

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

Factory Method模式是Abstract Factory模式的简化版本。工厂方法模式负责创建属于一个家族的产品，而抽象工厂模式负责处理多个产品家族。

Factory Method使用接口和抽象类将客户端与生成器类和生成的产品分离。抽象工厂具有一个生成器，该生成器是用于几种工厂方法的容器，以及将客户端与生成器和产品分离的接口。

何时使用工厂方法模式

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

何时使用抽象工厂模式

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

例子：

抽象工厂示例1

用于在面食制造商中准备不同类型的面食的磁盘的规范为“抽象工厂”，每个特定的磁盘为“工厂”。所有工厂（面食制作机磁盘）都从抽象工厂继承其属性。每个单独的磁盘都包含有关如何创建面食的信息，而面食制造商则没有。

抽象工厂示例2：

冲压设备对应于抽象工厂，因为它是用于创建抽象产品对象的操作的接口。模具与混凝土工厂相对应，因为它们创建混凝土产品。每个零件类别（护罩，门等）都对应于抽象产品。特定零件（即用于99佳美的驾驶员侧车门）对应于混凝土产品。

工厂方法示例：

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

工厂模式：工厂生产IProduct实现

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

[根据评论更新]至少
根据Wikipedia，我之前写的内容不正确。抽象工厂只是工厂接口。使用它，您可以在运行时切换工厂，以允许在不同的上下文中使用不同的工厂。示例可能是针对不同操作系统，SQL提供程序，中间件驱动程序等的不同工厂。

抽象工厂模式

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

• 抽象工厂模式与工厂方法模式非常相似。两者之间的区别是，在使用抽象工厂模式时，一个类通过组合将对象实例化的责任委托给另一个对象，而工厂方法模式则使用继承并依赖于子类来处理所需的对象实例化。

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

工厂模式

• 工厂模式是创造模式的示例

• 创建模式将对象实例化过程抽象化。它们隐藏了对象的创建方式，并有助于使整个系统独立于其对象的创建和组成方式。

• 类创建模式着重于使用继承来确定要实例化的对象的Factory方法

• 对象创建模式着重于将实例化委派给另一个对象Abstract Factory

参考： 工厂与抽象工厂

工厂方法：您有一个工厂可以创建从特定基类派生的对象

抽象工厂：您有一个工厂创建其他工厂，而这些工厂又创建了从基类派生的对象。这样做是因为您通常不希望创建单个对象（就像使用Factory方法一样），而是想要创建相关对象的集合。

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

基本区别：

工厂：创建对象时不将实例化逻辑暴露给客户端。

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

抽象工厂：提供一个用于创建相关或相关对象族的接口，而无需指定其具体类。

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

从oodesign文章：

工厂类图：

示例：StaticFactory

 public class ShapeFactory {

   //use getShape method to get object of type shape 
   public static Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }     
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();

      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();

      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }

      return null;
   }
}

这篇文章提供了实现FactoryMethod示例的非静态工厂：

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

什么时候使用：客户只需要一个类，而不在乎它要获得哪个具体实现。

工厂方法类digaram：

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

来自 dzone的抽象工厂类图

使用时间：系统必须创建多个产品系列时，或者您希望提供产品库而不公开实现细节时。

上面文章中的源代码示例很好地理解了这些概念。

相关的SE问题与代码示例：

工厂模式。什么时候使用工厂方法？

差异：

1. 抽象工厂类通常使用工厂方法来实现，但是它们也可以使用原型来实现
2. 设计从使用工厂方法开始（不那么复杂，更易于定制的子类激增），然后演变为需要更多灵活性的其他创建模式（更灵活，更复杂）。
3. 通常在模板方法中调用工厂方法。

其他有用的文章：

factory_method从sourcemaking

abstract_factory从sourcemaking

journaldev的抽象工厂设计模式

抽象工厂的示例/场景

我生活在雨季下雨，冬天下雪，夏天炎热而晴朗的地方。我需要不同种类的衣服来保护自己不受元素侵扰。为此，我去了我家附近的商店，要求穿衣服/物品以保护自己。店主会根据环境和口袋深度为我提供合适的物品。他给我的物品具有相同的质量和价格范围。由于他了解我的标准，因此很容易做到。但是，当街对面的一个有钱人提出相同的要求时，他会得到一件昂贵的品牌商品。一件值得注意的事情是他给我的所有物品在术语质量，标准和成本上都是相辅相成的。可以说他们彼此相处。这个有钱人得到的物品也是如此。

因此，通过查看上述情况，我现在很欣赏店主的效率。我可以用抽象商店代替这个店主。我们从抽象物品中获得的物品，而我和富人则成为透视客户。我们需要的就是适合我们需求的产品/物品。

现在，我可以很容易地看到自己正在考虑一家在线商店，该商店向众多客户提供一系列服务。每个客户都属于三个组之一。当高级用户打开网站时，他会获得出色的用户界面，高度自定义的广告窗格，菜单中的更多选项等。向金牌用户呈现这些相同的功能集，但菜单中的功能却较少，广告大多是相关的，以及更少的经济用户界面。最后是我的用户，一个“免费组”用户。我只是被提供足够的服务，所以我不会被冒犯。UI几乎是最低限度的，广告太偏离轨道了，以至于我不知道其中包含什么，最后菜单仅注销了。

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

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

也许很多人都会感到惊讶，但是这个问题是不正确的。如果您在面试中听到此问题，则需要帮助面试官了解混乱的地方。

让我们从没有被称为“工厂”的具体模式的事实开始。有一种模式称为“抽象工厂”，而有一种模式称为“工厂方法”。

那么，“工厂”是什么意思呢？以下内容之一（根据参考范围，可以认为全部正确）：

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

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

产品实现了由Factory创建的IProduct，该产品实现了由AbstractFactory创建的IFactory。

要了解这有多愚蠢，让我们继续方程式：

AbstractFactory实现IAbstractFactory，由... AbstractAbstractFactory创建。

我希望你明白这一点。不要感到困惑，请不要发明由于某种原因不存在的东西。

--

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

//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是一个抽象工厂，因为它提供了创建相关产品系列的方法。

请注意，Abstract工厂中的每个方法本身就是Factory方法。Like createDough()本身就是一种工厂方法，其具体实现将由like的子类提供NYPizzaIngredientsFactory。因此，使用此位置可以在每个不同的位置创建属于其位置的混凝土配料实例。

工厂方法

提供具体实施的实例

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

抽象工厂

提供创建相关对象族的界面

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

Head First设计模式的示例

我对约翰的回答有以下几点贡献：

抽象工厂是工厂工厂！

随着“工厂法”（因为只是“工厂”是不明确的），你生产的实现（Lemon，Orange特定的接口等） -比如，IFruit。这个工厂可以叫做CitricFruitFactory。

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

所以，你可以创建一个名为新厂RedFruitFactory产生Strawberry，Raspberry等等。

就像约翰·费米内拉（John Feminella）所说： “使用Abstract Factory模式，您将生成特定Factory接口的实现-例如，IFruitFactory。每个人都知道如何创建不同种类的水果。”

IFruitFactoryare CitricFruitFactory和RedFruitFactory！的实现。

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

Factory Method（也称为Factory）用于解耦Interface实现的客户端。对于示例，我们有一个Shape包含两个Circle和Square实现的接口。我们使用带有确定器参数的工厂方法定义了工厂类，例如接口的Type新实现Shape。

Abstract Factory包含多个工厂方法或多个工厂实现提供的工厂接口。对于上面的下一个示例，我们有一个Color包含2 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。Factory Method作为简单地返回接口的具体类，但Abstract Factory返回factory of factory。换句话说，Abstract Factory返回一系列接口的不同组合。

希望我的解释有用。

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

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

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

因此，我认为这也与对象的生存期和创建有关。

两者Factory Method并Abstract Factory保持客户与具体类型的分离。两者都创建对象，但是Factory方法使用继承，而Abstract Factory使用组合。

将Factory Method在子类继承创建具体的对象（产品），而Abstract Factory用于创建相关产品和这些接口的子类的家庭提供的接口定义如何创建相关产品。

然后，这些子类在实例化时传递到产品类中，在其中将其用作抽象类型。中的相关产品Abstract Factory通常使用来实现Factory Method。

扩展John Feminella答案：

Apple，Banana，Cherry工具FruitFactory和具有调用的方法Create是全权负责创建苹果或香蕉或樱桃。使用Factory方法完成。

现在，您想要Create从水果中提取特别的沙拉，然后您的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.
    }
}

根据定义，我们可以拖出两者的区别：

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

抽象工厂：抽象工厂模式是创建其他工厂的超级工厂。在Abstract Factory模式中，接口负责创建一组相关对象或从属对象，而无需指定其具体类。

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

工厂模式：

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

检查这里：http : //www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm 看来Factory方法使用一个特定的类（不是抽象的）作为基类，而Abstract工厂为此使用一个抽象的类。同样，如果使用接口而不是抽象类，则结果将是抽象工厂模式的不同实现。

：D

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

我认为我们可以通过查看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;
    }

}

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

第二种方法（使用Factory模式）：为您提供了可以传递任何类型的实现的好处，该实现可以基于某种条件（可能是传递给创建方法的参数）提供不同类型的事物。

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

请注意，您始终可以通过将两个条件组合在一起来使用Factory模式（这会稍微增加代码的复杂性和耦合性），我想这就是为什么我们很少看到Abstract Factory模式的实际用例的原因。