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

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

抽象工厂模式

• 提供一个用于创建 亲属或依亲家庭 对象而不指定其 具体课程

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

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

工厂模式

• 工厂模式就是这样的例子 创作模式

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

• 课堂创新模式的重点是 用继承来决定继承的方法 要实例化的对象 工厂法

• 对象创建模式的重点是 实例化的委托 指向另一个对象 抽象工厂

参考： 工厂模式： 工厂生产IPProduct实现

抽象工厂模式： 工厂生产IFactories，IFactories反过来生产IProducts:）

[根据评论更新]

---

我之前写的东西至少从理论上讲是不正确的。抽象工厂只是一个工厂接口。使用它，您可以在运行时切换工厂，以允许在不同的上下文中使用不同的工厂。例如，不同操作系统的不同工厂、SQL提供程序、中间件驱动程序等

使用工厂模式，可以生成特定接口的实现实例（

Apple

，

Banana

，

Cherry

，等等），例如，

IFruit

通过抽象工厂模式，您可以为任何人提供自己的工厂。这允许您的仓库成为

IFruitFactory

或

IJuiceFactory

，而无需您的仓库了解任何水果或果汁

此信息来源于：

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

抽象工厂模式由抽象工厂、具体工厂、抽象产品、具体产品和客户机组成

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

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

工厂方法使用接口和抽象类将客户机与生成器类和生成的产品解耦。抽象工厂有一个生成器，它是几种工厂方法的容器，以及将客户机与生成器和产品分离的接口

何时使用Factory方法模式 当需要将客户机与其使用的特定产品分离时，请使用Factory方法模式。使用工厂方法解除客户创建和配置产品实例的责任

何时使用抽象工厂模式 当客户机必须与产品类解耦时，使用抽象工厂模式。 特别适用于程序配置和修改。抽象工厂模式还可以强制约束哪些类必须与其他类一起使用。建造新的混凝土工厂可能需要很多工作

示例： 抽象工厂示例1 本规范适用于制备不同类型面食的圆盘 在面食制造者中是抽象工厂，每个特定的磁盘都是一个工厂。 所有工厂（面食制造商磁盘）都从抽象工厂继承其属性。 每个单独的磁盘都包含如何制作面食的信息，而面食制作者没有

抽象工厂示例2： 冲压设备对应于抽象工厂，因为它是一个 用于创建抽象产品对象的操作的接口。 模具对应于混凝土工厂，因为它们创建了混凝土产品。 每个零件类别（发动机罩、门等）对应于抽象产品。 特定零件（即99凯美瑞的驾驶员侧门）对应于 混凝土制品

工厂方法示例：

---

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

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

抽象工厂：您有一个创建其他工厂的工厂，这些工厂反过来创建从基类派生的对象。之所以这样做，是因为您通常不只是想要创建单个对象（与Factory方法一样），而是想要创建相关对象的集合

检查这里： 工厂法似乎使用

//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
} 

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

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

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.
    }
}

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

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

}