3 抽象工厂模式（Abstract Factory）

最新推荐文章于 2024-09-19 20:16:02 发布

蓝亦

最新推荐文章于 2024-09-19 20:16:02 发布

阅读量514

点赞数

分类专栏：设计模式文章标签：抽象工厂模式设计模式

本文链接：https://blog.csdn.net/finded/article/details/71512552

版权

设计模式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

3 抽象工厂模式（Abstract Factory）

—学习李建忠《设计模式》系列视频（C#）

常规的对象创建方法：
//创建一个Road对象
Road road =new Road();

new 的问题：
实现依赖，不能应对“具体实例化类型”的变化。

解决思路：
封装变化点—–哪里变化，封装哪里
潜台词：如果没有变化，当然不需要额外的封装！

3.1 工厂模式的缘起

变化点在“对象创建”，因此就封装“对象创建”

面向接口编程—-依赖接口，而非依赖实现

最简单的解决方法：

1 class RoadFactory{
2   public static Road CreateRoad()//static？
3   {                                
4       return new Road();   
5   }
6 }
7 //创建一个Road对象,客户端程序
8 Road road=roadFactory.CreateRoad();

3.2 （简单）工厂方法

创建一系列相互依赖对象：
假设一个游戏开场景：我们需要构造”道路”、”房屋”、”地道”，”从林”…等等对象

 1     class RoadFactory
 2     {
 3         public static Road CreateRoad()
 4         {
 5             return new Road();
 6         }
 7         public static Building CreateBuilding()
 8         {
 9             return new Building();
10         }
11         public static Tunnel CreateTunnel()
12         {
13             return new Tunnel();
14         }
15         public static Jungle CreateJungle()
16         {
17             return new Jungle();
18         }
19     }

     调用方式（稳定不变）如下： 
1         Road road =  RoadFactory.CreateRoad();
3         Building building = RoadFactory.CreateBuilding();
4         Tunnel tunnel = RoadFactory.CreateTunnel();
5         Jungle jungle = RoadFactory.CreateJungle();

如上可见简单工厂的问题：
不能应对”不同系列对象”的变化（上面调用方法相对稳定）。比如有不同风格的场景—对应不同风格的道路，房屋、地道….

如何解决：
使用面向对象的技术来“封装”变化点。

3.3 动机(Motivate)

在软件系统中，经常面临着”一系统相互依赖的对象”的创建工作（对象之间依赖关系不变）：同时，由于需求的变化，往往存在更多系列对象的创建工作。

如何应对这种变化？如何绕过常规的对象创建方法（new),提供一种”封装机制”来避免客户程序和这种”多系列具体对象创建工作”的紧耦合？

意图(Intent):
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 —-《设计模式》GOF

结构图（Struct):
这里写图片描述

3.4 适用性

1.一个系统要独立于它的产品的创建、组合和表示时。
2.一个系统要由多个产品系统中的一个来配置时。
3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。
4.当你提供一个产品类库，而只想显示它们的接口不是实现时。

结构图代码实现：

1  abstract class AbstractFactory
2     {
3        public abstract AbstractProductA CreateProductA();
4        public abstract AbstractProductB CreateProductB();
5     }

1   abstract class AbstractProductA
2     {
3        public abstract void Interact(AbstractProductB b);
4     }

1   abstract class AbstractProductB
2     {
3        public abstract void Interact(AbstractProductA a);
4     }

 1    class Client
 2     {
 3         private AbstractProductA AbstractProductA;
 4         private AbstractProductB AbstractProductB;
 5         public Client(AbstractFactory factory)
 6         {
 7             AbstractProductA = factory.CreateProductA();
 8             AbstractProductB = factory.CreateProductB();           
 9         }
10         public void Run()
11         {
12             AbstractProductB.Interact(AbstractProductA);
13             AbstractProductA.Interact(AbstractProductB);
14         }
15     }

 1  class ConcreteFactory1:AbstractFactory//具体工厂实现抽象工厂
 2     {
 3         public override AbstractProductA CreateProductA()
 4         {
 5             return new ProductA1();
 6         }
 7         public override AbstractProductB CreateProductB()
 8         {
 9             return new ProductB1();
10         }
11     }
 1     class ConcreteFactory2:AbstractFactory
 2     {
 3         public override AbstractProductA CreateProductA()
 4         {
 5             return new ProdcutA2();
 6         }
 7         public override AbstractProductB CreateProductB()
 8         {
 9             return new ProductB2();
10         }
11     }
1  class ProductA1:AbstractProductA
2     {
3         public override void Interact(AbstractProductB b)
4         {
5             Console.WriteLine(this.GetType().Name + "interact with" + b.GetType().Name);
6         }
7     }
1   class ProductB1:AbstractProductB
2     {
3         public override void Interact(AbstractProductA a)
4         {
5             Console.WriteLine(this.GetType().Name + "interact with" + a.GetType().Name);
6         }
7     }
1   class ProdcutA2:AbstractProductA
2     {
3         public override void Interact(AbstractProductB b)
4         {
5             Console.WriteLine(this.GetType().Name + "interact with" + b.GetType().Name);
6         }
7     }
1  class ProductB2:AbstractProductB
2     {
3         public override void Interact(AbstractProductA a)
4         {
5             Console.WriteLine(this.GetType().Name + "interact with" + a.GetType().Name);
6         }
7     }
 1    public static void Main()
 2         {
 3          // Abstractfactory1
 4             AbstractFactory factory1 = new ConcreteFactory1();
 5             Client c1 = new Client(factory1);
 6             c1.Run();
 7         // Abstractfactory2
 8             AbstractFactory factory2 = new ConcreteFactory2();
 9             Client c2 = new Client(factory2);
10             c2.Run();
11         }