是什么工厂和抽象工厂模式的基本区别？ [关闭] 是什么工厂和抽象工厂模式的基本区别？ [关闭]

2019-05-13 10:29发布

站内文章 / 前端开发

63 0

迷人小祖宗

女 | 书童

私信

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

Answer 1:

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

随着抽象工厂模式，你为任何人提供自己的工厂的方式。这使您的仓库是一个要么IFruitFactory或IJuiceFactory ，而不需要你的仓库了解水果或果汁任何东西。

Answer 2:

源出于此信息摘自： http://java.dzone.com/news/intro-design-patterns-abstract

抽象工厂与工厂方法

一个抽象工厂的方法是实现为工厂方法。无论是抽象工厂模式和工厂方法模式通过抽象类型和工厂解耦从实际实现类的客户端系统。该工厂方法通过继承，其中抽象工厂通过组成创建对象创建对象。

抽象工厂模式由一个AbstractFactory，ConcreteFactory，AbstractProduct，ConcreteProduct和客户端的。

如何实现

抽象工厂模式可以使用工厂方法模式，原型模式或Singleton模式来实现。所述ConcreteFactory对象可以被实现为一个Singleton为仅需要一个所述ConcreteFactory对象的实例。

工厂方法模式是Abstract Factory模式的一个简化版本。工厂方法模式负责创建属于一个系列产品，而抽象工厂模式与产品的多个家庭的交易。

工厂方法使用接口和抽象类解耦发电机类的客户端，并将所得的产品。抽象工厂有一台发电机是几个工厂方法的容器，使用接口从发电机和产品去耦客户一起。

当使用工厂方法模式

当有必要从它使用一个特定的产品解耦客户端使用工厂方法模式。使用工厂方法，以减轻责任的客户端创建和配置产品的实例。

何时使用抽象工厂模式

使用抽象工厂模式时，客户端必须从产品类别脱钩。尤其是对程序配置和修改是有用的。抽象工厂模式也可以执行哪些类必须与他人使用的限制。这可能是大量的工作，使新的混凝土工厂。

例子：

抽象工厂实施例1

该规范对磁盘的面条机准备不同类型的面食是抽象工厂，每一个具体的磁盘是一个工厂。所有工厂（面条机磁盘）继承抽象工厂它们的属性。每个磁盘包含如何创建面食的信息，以及面条机没有。

抽象工厂实施例2：

冲压设备对应于抽象工厂，因为它是用于创建抽象产品对象的操作接口。该模具对应于具体的工厂，为他们创造一个具体的产品。每个部分类别（罩，门等），对应于抽象产物。特定部分（即，驾驶员侧门99凯美）对应于混凝土制品。

工厂方法示例：

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

Answer 3:

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

抽象工厂模式：一个工厂，工厂生产IFactories，这反过来又产生IProducts :)

[更新根据注释]
我之前写的根据是不正确的维基百科至少。一个抽象工厂是一个简单的工厂接口。有了它，你可以在运行时切换你的工厂，允许在不同环境下不同的工厂。例子可能是不同的OS'es，SQL提供商，中间件，驱动器等不同的工厂..

Answer 4:

抽象工厂模式

用于创建相关或依赖的对象，而无需指定它们具体的类提供一个接口。
抽象工厂模式是非常相似的工厂方法模式。两者之间的一个区别是，与抽象工厂模式，一类代表对象实例化的另一个对象经由组合物而工厂方法模式的责任使用继承和依赖于一个子类来处理所期望的对象的实例化。
事实上，受委托的对象经常使用工厂方法来执行的实例！

工厂模式

工厂模式是创建模式的例子
创建模式抽象对象实例化过程。他们隐藏如何创建对象，并有助于使整个系统独立于如何创建和由它的对象。
类创建型模式注重利用继承的决定被实例工厂方法的对象
对象创建型模式注重实例代表团到另一个对象抽象工厂

参考： 工厂VS抽象工厂

Answer 5:

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

抽象工厂：你有一个工厂，创建其他工厂 ，这些工厂又创建一个从基类派生的对象。你这样做，因为你往往不只是想创建一个对象（如工厂方法） - 而是要创建的相关对象的集合。

Answer 6:

抽象工厂是用于创建相关对象，但工厂方法是一个方法的接口。抽象工厂是工厂方法来实现。

Answer 7:

基本区别：

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

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

抽象工厂 ：提供用于创建相关或依赖的对象，而无需指定它们具体的类的接口。

AbstractFactory模式使用组合物，同时该工厂方法图案使用继承和依赖于派生类或子类来创建对象委托创建对象到另一个类的责任

从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

何时使用：当你的系统创建的产品的多个家庭或你想提供的产品出库没有暴露的实现细节。

在上述文章的源代码的例子是很好理解的概念清晰。

Answer 8:

实施例/对场景抽象工厂

我住在一个地方，它在雨季下雨，下雪的冬天和炎热的夏天在阳光明媚。我需要不同类型的衣服，以保护自己的元素。要做到这一点，我去我家附近的商店，并要求服装/项目来保护自己。小店里的人给我合适的项目按我的口袋里的环境和深度。他给我的项目是质量和价格范围内的同一水平的。因为他知道我的标准，它很容易让他这样做。但是，当从街对面有钱人又发表了同样的要求，他得到一个昂贵的，品牌项目。一个值得注意的事情是所有他给我的项目在长期的质量，标准和成本相得益彰。可以说，他们去与对方。同样是这个有钱人获取项目的情况。

所以通过看上面的场景，我现在体会到店主的效率。我可以用一个抽象店更换该店主。该项目我们得到抽象的项目，我和丰富的视角的客户。我们需要的是产品/项目，适合我们的需要。

现在，我可以很容易地看到自己考虑一个在线商店，提供给其众多客户的一组服务。每个客户端所属的三组之一。当溢价组用户打开该网站，他被巨大的UI，高度定制的广告窗格，在菜单等，这些相同的功能集更多的选择呈现给用户的黄金，但在菜单中的功能比较少，广告多是培训相关，和略少egronomic UI。最后是我的类型的用户，“自由团”的用户。我只是担任足够让我不要生气。用户界面是一个最低限度，广告的方式偏离了轨道，以至于我不知道该怎么进来的，最后的菜单才注销。

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

摘要产品：广告面板，菜单，用户界面画家。
抽象工厂：网上商店用户体验
Concreate厂：高级用户体验，金牌用户体验，全面的用户体验。

Answer 9:

很多人会感到惊讶，也许，但是这个问题是不正确 。如果您在接受采访时听到这样的问题，你需要帮助面试官了解其中的混乱。

让我们从一个事实，即不存在，这只是所谓的“工厂”模式的具体启动。有图案被称为“抽象工厂”，有被称为“工厂法”的格局。

那么，什么是“工厂”的意思呢？以下（所有可以被认为是正确的，根据基准的范围）中的一个：

有些人用它作为“的别名（快捷方式）抽象工厂 ”。
有些人用它作为“的别名（快捷方式）工厂方法 ”。
有些人用它作为所有工厂/创建型模式更一般的名称。例如，既有“抽象工厂”和“工厂法”的工厂。

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

产品实现IProduct，这是由工厂，它实现IFactory的，这是由AbstractFactory创建创建。

要了解如何愚蠢这一点，让我们继续我们的公式：

AbstractFactory实现IAbstractFactory，这是由... AbstractAbstractFactory创建???

我希望你能看到这一点。不要误会，并请不发明的东西，不理性存在。

PS：出厂产品是AbstractFactory和工厂的工厂摘要将AbstractFactory的只是另一个例子也是如此。

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()本身是一种工厂方法，其具体的实现将用类似的子类来提供NYPizzaIngredientsFactory 。因此，使用这种每个不同位置可以创建属于自己的位置，具体成分的情况。

工厂方法

提供具体实现的实例

在这个例子：
- createDough() -提供了面团的具体实施。所以这是一个工厂方法

抽象工厂

提供接口来创建家族相关对象

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

从实施例头部首先设计模式

Answer 11:

我有一些要点如下与约翰的回答贡献：

抽象工厂是工厂的工厂！

随着“工厂法”（因为只是“工厂”是不明确的），你生产实现（ Lemon ， Orange特定接口等） -说， IFruit 。该工厂可称为CitricFruitFactory 。

但现在要创建另一个种水果的CitricFruitFactory是无法创建。也许的代码CitricFruitFactory如果你创建一个是没有意义的Strawberry在它（草莓是不是柠檬酸的水果！）。

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

就像约翰Feminella说：“ 随着抽象工厂模式，你产生特定工厂接口的实现-例如， IFruitFactory 。每个那些知道如何创建不同类型的水果。”

那implementatios IFruitFactory是CitricFruitFactory和RedFruitFactory ！

Answer 12:

在这些工厂的主要区别是，当你想要用的工厂做，当你想使用它。

有时，当你在做IOC（控制如构造器注入的反转），你知道，你可以创建固体物体。如上述水果的例子提到的，如果你已经准备好创建成果的对象，你可以使用简单工厂模式 。

但是很多时候，你不希望创建实体对象，他们将在程序流程晚一点。但配置告诉你什么样的你想在开始使用的，而不是创建对象的工厂，你可以通过在其上从一个普通的工厂类派生于IOC构造工厂。

所以，我认为它也对对象的生命周期和创造。

Answer 13:

扩展约翰Feminella的答案：

Apple ， Banana ， Cherry实现FruitFactory和具有调用的方法Create它全权负责创建苹果或香蕉或樱桃。大功告成，你的Factory方法。

现在，你要Create你的水果特别的沙拉，总会有你的抽象工厂 。抽象工厂知道如何创建您的特殊沙拉了苹果，香蕉和樱桃。

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 14:

我的来源是： 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 。 Factory Method简单地返回一个具体的类接口，但Abstract Factory返回factory of factory 。换句话说Abstract Factory返回不同组合的一系列接口的。

我希望我的解释是有用的。

Answer 15:

这两个Factory Method和Abstract Factory不断从具体类型分离的客户端。这两个创建对象，但Factory方法使用继承，而Abstract Factory使用的组合物。

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

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

Answer 16:

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

工厂：一个接口，用于创建一个对象，但子类决定哪一个类实例。对象的创建在需要时进行。

抽象工厂：抽象工厂模式作为一个超级工厂，造成其他工厂。在抽象工厂模式的接口负责创建一组相关对象，或依赖对象，而无需指定它们具体的类。

所以，在上面的定义，我们可以强调一个特别的差异。也就是说，工厂模式负责创建对象和抽象工厂负责创建一组相关对象的; 显然两者通过一个接口。

工厂模式：

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 17:

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

：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;
    }

}

现在的问题是创造哪种方式，你应该使用及原因：第一种方式（无图案，只是普通的构造函数）：由自己创造的不是一个好主意，你所要做的一切工作，和你的客户端代码绑具体的实施。

第二种方式（使用工厂模式）：提供你，你可以通过任何类型的实现，它可以提供不同类型的基于某些条件（也许传递给造物的方法的参数）的东西的好处。

第三种方式（使用抽象工厂模式）：这给你更多的灵活性。你可以找到不同类型的基于某些条件（也许传递参数）的一些创作者。

请注意，您可以使用工厂模式由两个条件组合在一起总是跑不掉（即稍微增加代码的复杂性，以及耦合），我想这就是为什么我们很少看到Abstract Factory模式的现实生活中的使用情况。

文章来源: What is the basic difference between the Factory and Abstract Factory Patterns? [closed]

标签： design-patterns factory abstract-factory factory-method