2.抽象工厂(Abstract Factory)

常规的对象创建方法:

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

new 的问题:

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

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

 class RoadFactory{
 public static Road CreateRoad()
 {
   return new Road();
 }
 }
 //创建一个Road对象
 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模式共同组合来应对“对象创建”的需求变化。

时间: 2024-10-13 12:02:35

2.抽象工厂(Abstract Factory)的相关文章

【设计模式】创建型模式之抽象工厂Abstract Factory

抽象工厂Abstract Factory是一种创建型设计模式,目的在于提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类.抽象工厂的类图如下,客户仅与抽象类定义的定义的接口交互,而不使用特定的具体类的接口.一个系统包含多种产品时,AbstractFactory声明创建各种抽象产品对象的操作接口,这些接口是直接暴露给Client的,而具体产品对象的创建则延迟到子类ConcreteFactory,Client面对的产品类是AbstractProduct,无需关系具体产品类是什么.在运

面向对象设计——抽象工厂(Abstract Factory)模式

定义 提供一个创建一系列相关或者相互依赖对象的接口,而无需指定它们具体的类.抽象工厂允许客户使用抽象的接口来创建一组相关的产品,而不需要知道或关心实际产出的具体产品是什么.这样一来,客户就能从具体的产品中被解耦. 适用场景 在以下情况可以使用Abstract Factory模式 一个系统要独立于它的产品的创建.组合和表示时 一个系统要由多个产品系列中的一个来配置时 当你要强调一系列相关的产品对象的设计以便进行联合使用时 当你提供一个产品类库,而只想显示它们的接口而不是实现时 UML图 抽象工厂模

抽象工厂(Abstract Factory)

定义 在软件设计中,如果客户想手动创建一个对象,需要知道对象的详细结构,包括其数据结构以及方法调用,如果运气不好,还可能因为该对象引用了其他对象,导致客户端还得了解其他对象,如此..使得该对象的创建变得复杂起来.之前讲过的工厂方法模式可以解决该类问题,不过工厂方法模式一般用来解决单个对象的创建,对于需要创建多个有关联的对象,那么可能就需要使用抽象工厂模式的方法了.此时,客户端只需要知道抽象出来的工厂以及自己所要的对象即可,不必清楚是谁创建以及怎样创建那些具体的对象. 抽象工厂的具体定义为:抽象工

工厂模式[3] 抽象工厂 Abstract Factory

简介 1.简单工厂,或静态工厂,产品接口 定义:专门定义一个类来负责创建其他类的实例,被创建的实例通常具有共同的父类或实现同一接口 优点:客户端可以直接消费产品,而不必关心具体产品的实现(不关心对象的构造方法是怎么new的),消除了客户端直接创建产品对象的责任,实现了对责任的分割. 缺点:工厂类记录了所有产品的创建逻辑,一旦不能正常工作,整个系统都会受到影响:而且当产品种类多.结构复杂的时候,把所有创建工作放进一个工厂中来,会使后期程序的扩展较为困难. 2.工厂方法,工厂接口+产品接口 定义:在

设计模式(一) 抽象工厂(Abstract Factory)

1.定义 抽象工厂是一种常用的对象创建型设计模式.抽象工厂模式提供了一种方式,可以将一组具有统一主题的单独工厂封装起来,它提供一个创建一系列相关或相互依赖对象的接口,而无需制定它们具体的类. 2.结构 抽象工厂的结构图如下所示: AbstractFactory : 声明一个创建抽象产品对象的操作接口 ConcreteFactory : 实现创建具体产品对象的操作 AbstractProduct : 为一个类产品对象声明一个接口 ConcreteProduct : 定义一个将被相应的具体工厂创建产

【设计模式】——抽象工厂Abstract Factory

模式意图 提供对象的使用接口,隐藏对象的创建过程. 模式结构 AbstractFactory 提供创建对象的接口. ConcreteFactory 提供真正创建对象的实现类,用于组合并创建不同的对象,实现一个产品族. AbstractProduct 提供对象的使用接口. ConcreteProduct 提供真正的适用对象,隐藏该对象的创建过程,是工厂创建的对象. Client 使用者,通过抽象工厂接口,使用不同的具体工厂方法创建对象组合,从而直接使用对象,无需关注对象的创建过程. 适合场景 1

Headfirst设计模式的C++实现——抽象工厂(Abstract Factory)

Dough.h 1 #ifndef _DOUGH_H 2 #define _DOUGH_H 3 4 class Dough 5 { 6 }; 7 #endif ThinCrustDough.h 1 #ifndef _THIN_CRUST_DOUGH_H 2 #define _THIN_CRUST_DOUGH_H 3 4 #include "Dough.h" 5 6 class ThinCrustDough : public Dough 7 { 8 }; 9 #endif Sauce.h

设计模式 - 抽象工厂模式(abstract factory pattern) 详解

抽象工厂模式(abstract factory pattern) 详解 本文地址: http://blog.csdn.net/caroline_wendy/article/details/27091671 参考工厂模式: http://blog.csdn.net/caroline_wendy/article/details/27081511 抽象工厂模式: 提供一个接口, 用于创建相关或依赖对象的家族, 而不需要明确指定具体类. 全部代码: http://download.csdn.net/de

设计模式 - 抽象工厂模式(abstract factory pattern) 具体解释

抽象工厂模式(abstract factory pattern) 详细解释 本文地址: http://blog.csdn.net/caroline_wendy/article/details/27091671 參考工厂模式: http://blog.csdn.net/caroline_wendy/article/details/27081511 抽象工厂模式: 提供一个接口, 用于创建相关或依赖对象的家族, 而不须要明白指定详细类. 所有代码: http://download.csdn.net/

一天一个设计模式——Abstract Factory抽象工厂模式

一.模式说明 前面学习了工厂方法(Factory Method)模式.在工厂方法模式中,在工厂方法模式中,父类决定如何生成实例,但并不决定所要生成的具体类,具体的处理交由子类来处理.这里学习的抽象工厂方法模式中,抽象工厂使用抽象的零件组装成抽象的产品.即使用包含特定的方法接口零件,将零件组装成抽象产品. 二.模式类图: 上面的类图中包含两个包:包含抽象工厂,抽象零件,抽象产品的类所在的包以及具体工厂实现类的包. 三.代码示例 1.Item类: package com.designpattern.