12抽象工厂（Abstract Factory）

常规的对象创建方法：

//创建一个Road对象
Road road =new Road();

new 的问题：
    实现依赖，不能应对“具体实例化类型”的变化。
解决思路：
    封装变化点-----哪里变化，封装哪里
    潜台词：如果没有变化，当然不需要额外的封装！

工厂模式的缘起
变化点在“对象创建”，因此就封装“对象创建”
面向接口编程----依赖接口，而非依赖实现
最简单的解决方法：

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

创建一系列相互依赖对象的创建工作：
假设一个游戏开场景：
我们需要构造"道路"、"房屋"、"地道"，"从林"...等等对象
工厂方法如下：

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

如上可见简单工厂的问题：
不能应对"不同系列对象"的变化。比如有不同风格的场景---对应不同风格的道路，房屋、地道....

如何解决：
    使用面向对象的技术来"封装"变化点。
动机(Motivate)：
    在软件系统中，经常面临着"一系统相互依赖的对象"的创建工作：同时，由于需求的变化，往往存在更多系列对象的创建工作。
    如何应对这种变化？如何绕过常规的对象创建方法（new),提供一种"封装机制"来避免客户程序和这种"多系列具体对象创建工作"的紧耦合？

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

适用性：
    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         }

Abstract Factory注意的几点：
如果不存在”多系列对象创建“的需求变化，则没必要应用Abstract Factory模式，静态工厂方法足矣。
"系列对象"指的是这些对象之间有相互依赖、或作用的关系。例如游戏开发场景中的"道路"与"房屋"依赖，“道路”与“地道”的依赖。
Abstract Factory模式主要在于应对"新系列"的需求变动。其缺点在于难以应对”新对象“的需求变动。
Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。

分类: 设计模式, 1.首页原创精华.NET区

好文要顶关注我收藏该文

王晓成
关注 - 1
粉丝 - 108

+加关注

« 上一篇：单件模式(Singleton Pattern)
» 下一篇：建造者模式(Builder)

posted on 2007-08-29 17:25 王晓成阅读(15809) 评论(3) 编辑收藏

Feedback

#1楼 2008-05-21 09:08 xingxi

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 }
此段代码中，Building、Road 等是在何处定义的啊？
谢谢给予明示

支持(0) 反对(0)

#2楼2008-07-08 01:57 21212

--引用-------------------------------------------------- xingxi: 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 } 此段代码中，Building、Road 等是在何处定义的啊？谢谢给予明示 --------------------------------------------------------

这还用定义吗，这篇文章说的是一种设计模式，不是教你定义类。

12抽象工厂（Abstract Factory）相关推荐

设计模式学习笔记——抽象工厂(Abstract Factory)模式
设计模式学习笔记--抽象工厂(Abstract Factory)模式 @(设计模式)[设计模式, 设计模式中文名, 设计模式英文名] 设计模式学习笔记抽象工厂Abstract Factory模式基本 ...
设计模式--抽象工厂(Abstract Factory)模式
模式定义提供一个创建一系列相关或互相依赖对象的接口,而无需指定它们具体的类类图应用场景程序需要处理不同系列的相关产品,但是你不希望它依赖于这些产品的具体类时可以使用抽象工厂模式优点 1.可以 ...
[设计模式-创建型]抽象工厂(Abstract Factory)
概括名称 Abstract Factory 结构动机提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 适用性一个系统要独立于它的产品的创建.组合和表示时. 一个系统要由多个 ...
C2:抽象工厂 Abstract Factory
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 应用场景: 一系列相互依赖的对象有不同的具体实现.提供一种"封装机制"来避免客户程序和这种"多系列具 ...
设计模式抽象工厂(Abstract Factory Pattern)
抽象工厂模式,比工厂模式具有更高层次的抽象.当要返回一系列相关类中的某一个,而每个类都能根据需要返回不同的对象时,可以使用这种模式.换句话说,抽象工厂是一个工厂对象,他能返回一系列相关类中的一个类.可 ...
c++设计模式--抽象工厂(abstract factory)
一.原理讲解为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类. 1.1意图定义一个创建对象的接口,让子类决定实例化哪个类.该模式使类对象的创建延迟到子类. 1.2应用场景一个 ...
《研磨设计模式》chap7 抽象工厂 Abstract Factory
场景:配电脑,多种CPU.主板 1. 正常编码 1.1 cpu //CPU的接口 public interface CPUApi {//示意方法,CPU具有运算的功能 public void calc ...
设计模式 - 抽象工厂模式(abstract factory pattern) 详解
抽象工厂模式(abstract factory pattern) 详解本文地址: http://blog.csdn.net/caroline_wendy/article/details/270916 ...
『创建型』简单工厂SimpleFactory、工厂方法FactoryMethod、抽象工厂AbstractFactory
为什么80%的码农都做不了架构师?>>> 几点说明永远不要纠结于在什么时候使用什么模式永远不要纠结于什么模式适用于什么情景永远不要去死记任何的模式并不是说,23种设计模 ...
java抽象工厂模式_JAVA设计模式-抽象工厂模式
定义抽象工厂(AbstractFactory)模式的定义:是一种为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构. 抽象工厂模 ...

12抽象工厂（Abstract Factory）

Feedback

12抽象工厂（Abstract Factory）相关推荐

最新文章

热门文章