常规的对象创建方法:
//
创建一个Road对象
Road road = new 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();
创建一系列相互依赖对象的创建工作:
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 }
调用方式如下:
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 Building building = RoadFactory.CreateBuilding();
4 Tunnel tunnel = RoadFactory.CreateTunnel();
5 Jungle jungle = RoadFactory.CreateJungle();
不能应对"不同系列对象"的变化。比如有不同风格的场景---对应不同风格的道路,房屋、地道....
如何解决:
使用面向对象的技术来"封装"变化点。
动机(Motivate):
在软件系统中,经常面临着"一系统相互依赖的对象"的创建工作:同时,由于需求的变化,往往存在更多系列对象的创建工作。
如何应对这种变化?如何绕过常规的对象创建方法(new),提供一种"封装机制"来避免客户程序和这种"多系列具体对象创建工作"的紧耦合?
意图(Intent):
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
----《设计模式》GOF
结构图(Struct):
![](https://i-blog.csdnimg.cn/blog_migrate/9e472cadda4fc7afec59c8d509ff65e8.jpeg)
适用性:
1.一个系统要独立于它的产品的创建、组合和表示时。
2.一个系统要由多个产品系统中的一个来配置时。
3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。
4.当你提供一个产品类库,而只想显示它们的接口不是实现时。
生活例子:
![](https://i-blog.csdnimg.cn/blog_migrate/08e44bf1987c177aa3d4afe35436b2b0.jpeg)
结构图代码实现:
1
abstract
class
AbstractFactory
2 {
3 public abstract AbstractProductA CreateProductA();
4 public abstract AbstractProductB CreateProductB();
5 }
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 }
2 {
3 public abstract void Interact(AbstractProductB b);
4 }
1
abstract
class
AbstractProductB
2 {
3 public abstract void Interact(AbstractProductA a);
4 }
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 }
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 }
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 }
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 }
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 }
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 }
如果不存在”多系列对象创建“的需求变化,则没必要应用Abstract Factory模式,静态工厂方法足矣。
"系列对象"指的是这些对象之间有相互依赖、或作用的关系。例如游戏开发场景中的"道路"与"房屋"依赖,“道路”与“地道”的依赖。
Abstract Factory模式主要在于应对"新系列"的需求变动。其缺点在于难以应对”新对象“的需求变动。
Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。
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 }
Abstract Factory注意的几点:
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 }
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模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。