抽象工厂模式-yiteyi-C++库

介绍

null

摘要工厂设计模式是创新模式之一。抽象工厂模式几乎类似于工厂模式被认为是工厂模式的另一个抽象层。抽象工厂模式围绕着创建其他工厂的超级工厂工作。抽象工厂模式实现为我们提供了一个框架，允许我们创建遵循一般模式的对象。因此，在运行时，抽象工厂与任何可以创建所需类型的对象的所需具体工厂耦合。 让我们看看抽象工厂模式的GOFs表示：

图片[1]-抽象工厂模式-yiteyi-C++库

抽象工厂设计模式的UML类图示例。

抽象工厂模式 ：为创建抽象产品对象的操作声明接口。
具体工厂 ：实现AbstractFactory中声明的操作，以创建具体的产品对象。
产品：定义一个由相应的具体工厂创建的产品对象，并实现AbstractProduct接口。
客户：仅使用AbstractFactory和AbstractProduct类声明的接口。

抽象工厂提供了创建相关或从属对象族的接口，而无需指定它们的具体类。客户端软件创建抽象工厂的具体实现，然后使用通用接口创建作为对象族一部分的具体对象。客户不知道或不关心从每个具体工厂获得哪些具体对象，因为它只使用其产品的通用接口。因此，有了抽象工厂模式的想法，我们现在将尝试创建一个设计，以促进相关对象的创建。

实施

让我们举个例子，假设我们想要建立一个全球性的汽车工厂。如果是一个工厂设计模式，则适用于单个位置。但对于这种模式，我们需要多个位置和一些关键的设计更改。我们需要像IndiaCarFactory、USACarFactory和DefaultCarFactory这样的汽车工厂。现在，我们的应用程序应该足够智能，能够识别正在使用它的位置，因此我们应该能够使用适当的汽车工厂，而不知道内部将使用哪个汽车工厂实现。这也避免了有人在某个特定地点给错误的工厂打电话。在这里，我们需要另一层抽象，它将识别位置，并在内部使用正确的汽车工厂实现，而无需向用户提供任何提示。这正是使用抽象工厂模式来解决的问题。

JAVA

                         // Java Program to demonstrate the                       
                         // working of Abstract Factory Pattern                       
           
                         enum                                     CarType                       
                         {                       
                                                 MICRO, MINI, LUXURY                       
                         }                       
           
                         abstract                                     class                                     Car                       
                         {                       
                                                 Car(CarType model, Location location)                       
                                                 {                       
                                                 this                                     .model = model;                       
                                                 this                                     .location = location;                       
                                                 }                       
                                   
                                                 abstract                                     void                                     construct();                       
                                   
                                                 CarType model =                                     null                                     ;                       
                                                 Location location =                                     null                                     ;                       
                                   
                                                 CarType getModel()                       
                                                 {                       
                                                 return                                     model;                       
                                                 }                       
                                   
                                                 void                                     setModel(CarType model)                       
                                                 {                       
                                                 this                                     .model = model;                       
                                                 }                       
                                   
                                                 Location getLocation()                       
                                                 {                       
                                                 return                                     location;                       
                                                 }                       
                                   
                                                 void                                     setLocation(Location location)                       
                                                 {                       
                                                 this                                     .location = location;                       
                                                 }                       
                                   
                                                 @Override                       
                                                 public                                     String toString()                       
                                                 {                       
                                                 return                                     "CarModel - "                                     +model +                                     " located in "                                     +location;                       
                                                 }                       
                         }                       
           
                         class                                     LuxuryCar                                     extends                                     Car                       
                         {                       
                                                 LuxuryCar(Location location)                       
                                                 {                       
                                                 super                                     (CarType.LUXURY, location);                       
                                                 construct();                       
                                                 }                       
                                                 @Override                       
                                                 protected                                     void                                     construct()                       
                                                 {                       
                                                 System.out.println(                                     "Connecting to luxury car"                                     );                       
                                                 }                       
                         }                       
           
                         class                                     MicroCar                                     extends                                     Car                       
                         {                       
                                                 MicroCar(Location location)                       
                                                 {                       
                                                 super                                     (CarType.MICRO, location);                       
                                                 construct();                       
                                                 }                       
                                                 @Override                       
                                                 protected                                     void                                     construct()                       
                                                 {                       
                                                 System.out.println(                                     "Connecting to Micro Car "                                     );                       
                                                 }                       
                         }                       
           
                         class                                     MiniCar                                     extends                                     Car                       
                         {                       
                                                 MiniCar(Location location)                       
                                                 {                       
                                                 super                                     (CarType.MINI,location );                       
                                                 construct();                       
                                                 }                       
                                   
                                                 @Override                       
                                                 void                                     construct()                       
                                                 {                       
                                                 System.out.println(                                     "Connecting to Mini car"                                     );                       
                                                 }                       
                         }                       
           
                         enum                                     Location                       
                         {                       
                                                 DEFAULT, USA, INDIA                       
                         }                       
           
                         class                                     INDIACarFactory                       
                         {                       
                                                 static                                     Car buildCar(CarType model)                       
                                                 {                       
                                                 Car car =                                     null                                     ;                       
                                                 switch                                     (model)                       
                                                 {                       
                                                 case                                     MICRO:                       
                                                 car =                                     new                                     MicroCar(Location.INDIA);                       
                                                 break                                     ;                       
                                   
                                                 case                                     MINI:                       
                                                 car =                                     new                                     MiniCar(Location.INDIA);                       
                                                 break                                     ;                       
                                   
                                                 case                                     LUXURY:                       
                                                 car =                                     new                                     LuxuryCar(Location.INDIA);                       
                                                 break                                     ;                       
                                   
                                                 default                                     :                       
                                                 break                                     ;                       
                                   
                                                 }                       
                                                 return                                     car;                       
                                                 }                       
                         }                       
           
                         class                                     DefaultCarFactory                       
                         {                       
                                                 public                                     static                                     Car buildCar(CarType model)                       
                                                 {                       
                                                 Car car =                                     null                                     ;                       
                                                 switch                                     (model)                       
                                                 {                       
                                                 case                                     MICRO:                       
                                                 car =                                     new                                     MicroCar(Location.DEFAULT);                       
                                                 break                                     ;                       
                                   
                                                 case                                     MINI:                       
                                                 car =                                     new                                     MiniCar(Location.DEFAULT);                       
                                                 break                                     ;                       
                                   
                                                 case                                     LUXURY:                       
                                                 car =                                     new                                     LuxuryCar(Location.DEFAULT);                       
                                                 break                                     ;                       
                                   
                                                 default                                     :                       
                                                 break                                     ;                       
                                   
                                                 }                       
                                                 return                                     car;                       
                                                 }                       
                         }                       
           
           
                         class                                     USACarFactory                       
                         {                       
                                                 public                                     static                                     Car buildCar(CarType model)                       
                                                 {                       
                                                 Car car =                                     null                                     ;                       
                                                 switch                                     (model)                       
                                                 {                       
                                                 case                                     MICRO:                       
                                                 car =                                     new                                     MicroCar(Location.USA);                       
                                                 break                                     ;                       
                                   
                                                 case                                     MINI:                       
                                                 car =                                     new                                     MiniCar(Location.USA);                       
                                                 break                                     ;                       
                                   
                                                 case                                     LUXURY:                       
                                                 car =                                     new                                     LuxuryCar(Location.USA);                       
                                                 break                                     ;                       
                                   
                                                 default                                     :                       
                                                 break                                     ;                       
                                   
                                                 }                       
                                                 return                                     car;                       
                                                 }                       
                         }                       
           
           
           
                         class                                     CarFactory                       
                         {                       
                                                 private                                     CarFactory()                       
                                                 {                       
                                   
                                                 }                       
                                                 public                                     static                                     Car buildCar(CarType type)                       
                                                 {                       
                                                 Car car =                                     null                                     ;                       
                                                 // We can add any GPS Function here which                       
                                                 // read location property somewhere from configuration                       
                                                 // and use location specific car factory                       
                                                 // Currently I'm just using INDIA as Location                       
                                                 Location location = Location.INDIA;                       
                                   
                                                 switch                                     (location)                       
                                                 {                       
                                                 case                                     USA:                       
                                                 car = USACarFactory.buildCar(type);                       
                                                 break                                     ;                       
                                   
                                                 case                                     INDIA:                       
                                                 car = INDIACarFactory.buildCar(type);                       
                                                 break                                     ;                       
                                   
                                                 default                                     :                       
                                                 car = DefaultCarFactory.buildCar(type);                       
           
                                                 }                       
                                   
                                                 return                                     car;                       
           
                                                 }                       
                         }                       
           
                         class                                     AbstractDesign                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 System.out.println(CarFactory.buildCar(CarType.MICRO));                       
                                                 System.out.println(CarFactory.buildCar(CarType.MINI));                       
                                                 System.out.println(CarFactory.buildCar(CarType.LUXURY));                       
                                                 }                       
                         }                       

输出：

Connecting to Micro Car CarModel - MICRO located in INDIAConnecting to Mini carCarModel - MINI located in INDIAConnecting to luxury carCarModel - LUXURY located in INDIA

差别

“工厂方法”和“抽象工厂”的主要区别在于，工厂方法是一个单一的方法，而抽象工厂是一个对象。
工厂方法只是一个方法，它可以在子类中被重写，而抽象工厂是一个有多个工厂方法的对象。
工厂方法模式使用继承，并依赖子类来处理所需的对象实例化。

优势： 当客户机不知道要创建什么类型时，这种模式特别有用。

混凝土等级的隔离： 抽象工厂模式帮助您控制应用程序创建的对象类。因为工厂封装了创建产品对象的职责和过程，所以它将客户机与实现类隔离开来。客户机通过抽象接口操作实例。在混凝土工厂的实施中，产品类别名称是孤立的；它们不会出现在客户端代码中。
轻松交换产品系列： 一个具体工厂的类在一个应用程序中只出现一次，也就是它被实例化的地方。这使得更改应用程序使用的混凝土工厂变得很容易。它可以通过改变混凝土工厂来使用各种产品配置。因为抽象工厂创建了一个完整的产品系列，所以整个产品系列会立即发生变化。
促进产品之间的一致性： 当一个系列中的产品对象被设计为协同工作时，应用程序一次只能使用一个系列中的对象是很重要的。AbstractFactory使其易于实施。N

缺点

难以支持新型产品： 扩大抽象工厂以生产新产品并不容易。这是因为AbstractFactory接口修复了可以创建的产品集。支持新类型的产品需要扩展factory接口，这涉及到更改AbstractFactory类及其所有子类。

在某种程度上，上面的例子也是基于uber和ola等出租车的大规模运作。 进一步阅读： Python中的抽象工厂方法本文由 萨凯特·库马尔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章