设计模式之抽象工程模式

1.定义:提供一个创建一系列相关或相互依赖对象接口,而无需指定它们的实体类。

2.引申:

每个模式都是针对一定问题的解决方案。抽象工厂模式面对的问题是多产品等级结构的系统设计。
         在学习抽象工厂具体实例之前,应该明白两个重要的概念:产品族和产品等级。

产品族:是指位于不同产品等级结构中,功能相关联的产品组成的家族。比如AMD的CPU和ADM芯片的主板,组成一个家族。Intel的CPU和Intel芯片的主板,又组成一个家族。而这两个家族都来自于两个产品等级:CPU,主板。一个等级结构是由相同的结构的产品组成,示意图如下:

理解这个产品结构是理解抽象工厂模式的关键所在,从上图可以看出,抽象工厂模式的每个工厂创造出来的都是一族产品,而不是一个或者一组。组是可以随意组合的!其实工厂方法模式和抽象工厂模式就这点点差别。

2.组成:

  抽象工厂:

  具体工厂:

  抽象产品:

  具体产品:

3.UML类图:

我们先看一下抽象工厂模式的UML结构图:

上图是 Abstract Factory 模式结构图,让我们可以进行更加方便的描述:

  1. AbstractProduct: 抽象产品,它们都有可能有两种不同的实现。
  2. ConcreteProduct:包括ProductA和ProductB, 对两个抽象产品的具体分类的实现。
  3. AbstractFactory: 抽象工厂接口,它里面应该包含所有的产品创建的抽象方法。
  4. ConcreteFactory: 包括ConcreteFactoryA和ConcreteFactoryB,具体的工厂,创建具有特定实现的产品对象。

4:示例:

背景:用一个分别对不同数据库(Oracle 或 SQL Server)中表( User 和 Department )的操作的实例来展示该设计模式。先看下代码的结构图:

3.1 首先定义两个抽象的产品类:IUser.java 和 IDepartment.java。

IUser.java的源码:

[html] view plaincopy

  1. package com.andyidea.patterns.abstractproduct;
  2. /**
  3. * 抽象产品角色:User接口
  4. * @author Andy.Chen
  5. *
  6. */
  7. public interface IUser {
  8. }

IDepartment.java源码:

[html] view plaincopy

  1. package com.andyidea.patterns.abstractproduct;
  2. /**
  3. * 抽象产品角色:Department接口
  4. * @author Andy.Chen
  5. *
  6. */
  7. public interface IDepartment {
  8. }

3.2 定义抽象工厂类:IDBFactory.java

[html] view plaincopy

  1. package com.andyidea.patterns.abstractfactory;
  2. import com.andyidea.patterns.abstractproduct.IDepartment;
  3. import com.andyidea.patterns.abstractproduct.IUser;
  4. /**
  5. * 抽象工厂角色:工厂接口
  6. * @author Andy.Chen
  7. *
  8. */
  9. public interface IDBFactory {
  10. public IUser createUser();
  11. public IDepartment createDepartment();
  12. }

3.3创建具体产品角色类:OracleOfUser.java;OracleOfDepartment.java;SQLServerOfUser.java;SQLServerOfDepartment.java。分别继承IUser.java和IDepartment.java。

OracleOfUser.java源码:

[html] view plaincopy

  1. package com.andyidea.patterns.concreteproduct;
  2. import com.andyidea.patterns.abstractproduct.IUser;
  3. /**
  4. * 具体产品角色:Oracle中的User
  5. * @author Andy.Chen
  6. *
  7. */
  8. public class OracleOfUser implements IUser{
  9. public OracleOfUser(){
  10. System.out.println("Oracle工厂:在Oracle中操作User表.");
  11. }
  12. }

OracleOfDepartment.java源码:

[html] view plaincopy

  1. package com.andyidea.patterns.concreteproduct;
  2. import com.andyidea.patterns.abstractproduct.IDepartment;
  3. /**
  4. * 具体产品角色:Oracle中的Department
  5. * @author Andy.Chen
  6. *
  7. */
  8. public class OracleOfDepartment implements IDepartment{
  9. public OracleOfDepartment(){
  10. System.out.println("Oracle工厂:在Oracle中操作Department表.");
  11. }
  12. }

SQLServerOfUser.java源码:

[html] view plaincopy

  1. package com.andyidea.patterns.concreteproduct;
  2. import com.andyidea.patterns.abstractproduct.IUser;
  3. /**
  4. * 具体产品角色:SQL Server中的User
  5. * @author Andy.Chen
  6. *
  7. */
  8. public class SQLServerOfUser implements IUser{
  9. public SQLServerOfUser(){
  10. System.out.println("SQL Server工厂:在SQL Server中操作User表.");
  11. }
  12. }

SQLServerOfDepartment.java源码:

[html] view plaincopy

  1. package com.andyidea.patterns.concreteproduct;
  2. import com.andyidea.patterns.abstractproduct.IDepartment;
  3. /**
  4. * 具体产品角色:SQL Server中的Department
  5. * @author Andy.Chen
  6. *
  7. */
  8. public class SQLServerOfDepartment implements IDepartment{
  9. public SQLServerOfDepartment(){
  10. System.out.println("SQL Server工厂:在SQL Server中操作Department表.");
  11. }
  12. }

3.4 创建具体工厂类:OracleFactory.java和SQLServerFactory.java。

OracleFactory.java源码:

[html] view plaincopy

  1. package com.andyidea.patterns.concretefactory;
  2. import com.andyidea.patterns.abstractfactory.IDBFactory;
  3. import com.andyidea.patterns.abstractproduct.IDepartment;
  4. import com.andyidea.patterns.abstractproduct.IUser;
  5. import com.andyidea.patterns.concreteproduct.OracleOfDepartment;
  6. import com.andyidea.patterns.concreteproduct.OracleOfUser;
  7. /**
  8. * 具体工厂角色:Oracle工厂
  9. * @author Andy.Chen
  10. *
  11. */
  12. public class OracleFactory implements IDBFactory{
  13. @Override
  14. public IUser createUser() {
  15. return new OracleOfUser();
  16. }
  17. @Override
  18. public IDepartment createDepartment() {
  19. return new OracleOfDepartment();
  20. }
  21. }

SQLServerFactory.java源码:

[html] view plaincopy

  1. package com.andyidea.patterns.concretefactory;
  2. import com.andyidea.patterns.abstractfactory.IDBFactory;
  3. import com.andyidea.patterns.abstractproduct.IDepartment;
  4. import com.andyidea.patterns.abstractproduct.IUser;
  5. import com.andyidea.patterns.concreteproduct.SQLServerOfDepartment;
  6. import com.andyidea.patterns.concreteproduct.SQLServerOfUser;
  7. /**
  8. * 具体工厂角色:SQL Server工厂
  9. * @author Andy.Chen
  10. *
  11. */
  12. public class SQLServerFactory implements IDBFactory{
  13. @Override
  14. public IUser createUser() {
  15. return new SQLServerOfUser();
  16. }
  17. @Override
  18. public IDepartment createDepartment() {
  19. return new SQLServerOfDepartment();
  20. }
  21. }

3.5 客户端测试类:AbstractFactoryClient.java

[html] view plaincopy

  1. package com.andyidea.patterns.client;
  2. import com.andyidea.patterns.abstractproduct.IDepartment;
  3. import com.andyidea.patterns.abstractproduct.IUser;
  4. import com.andyidea.patterns.concretefactory.OracleFactory;
  5. import com.andyidea.patterns.concretefactory.SQLServerFactory;
  6. /**
  7. * 抽象工厂测试类
  8. * @author Andy.Chen
  9. *
  10. */
  11. public class AbstractFactoryClient {
  12. public static void main(String[] args) {
  13. System.out.println("Welcome to Andy.Chen Blog!" +"\n"
  14. +"Abstract Factory Patterns." +"\n"
  15. +"-------------------------------");
  16. IUser oracleUser,sqlUser;
  17. IDepartment oracleDept,sqlDept;
  18. OracleFactory of = new OracleFactory();
  19. SQLServerFactory sf = new SQLServerFactory();
  20. oracleUser = of.createUser();
  21. oracleDept = of.createDepartment();
  22. sqlUser = sf.createUser();
  23. sqlDept = sf.createDepartment();
  24. }
  25. }

【4】程序运行结果:

[html] view plaincopy

  1. Welcome to Andy.Chen Blog!
  2. Abstract Factory Patterns.
  3. -------------------------------
  4. Oracle工厂:在Oracle中操作User表.
  5. Oracle工厂:在Oracle中操作Department表.
  6. SQL Server工厂:在SQL Server中操作User表.
  7. SQL Server工厂:在SQL Server中操作Department表.

5.应用总结:

抽象工厂模式优点:

第一,易于交换产品系列,由于具体工厂类,例如IDBFactory factory = new OracleFactory(),在一个应用中只需要在初始化的时候出现一次,这就使得改变一个应用的具体工厂变得非常容易,它之需要改变具体工厂即可使用不同的产品配置。
第二,它让具体的创建实例与客户端分离,客户端是通过它们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离,不会出现在客户端代码中。

6.扩展:

  +反射+配置文件进一步满足OO的五大原则

时间: 2024-11-03 21:14:48

设计模式之抽象工程模式的相关文章

设计模式之抽象工厂模式

抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 最大的好处便是易于交换产品系列,由于具体工厂类,在一个应用中只需在初始化的时候出现一次,这就使得改变一个应用的具体工厂变得非常容易,它只需改变具体工厂即可使用不同的产品配置. 他使具体创建实例的过程与客户端分离,客户端是通过它们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离. 下面的代码还使用了反射与XML. 代码如下: using System; using System.Collections.Ge

设计模式之抽象工厂模式20170803

创建型设计模式之抽象工厂模式: 一.含义 为创建一组相关或相互依赖的对象提供一个接口,而且无需指定它们的具体类. 具体来说, 为一组具有相同约束(属性)的对象,提供一个接口,这个接口下有不同的实现,每个实现类对应一种类型的约束(一种具体的属性),同时提供该类型的约束(属性)下所有对象的创建方法 二.代码说明 1.主要有两个角色 1)一组互相影响的产品线(对象),也叫做产品族 2)抽象工厂类及其实现类 抽象工厂类:在N个产品族中,在抽象工厂类中就应该有N个创建方法 实现类:具体实现类是产品族的具体

大话设计模式_抽象工厂模式(Java代码)

抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类. 简单描述:有多种抽象产品,并且每种抽象产品都有多个具体产品.一个抽象工厂,提供多个具体工厂,每个工厂则提供不同种类的具体产品. 大话设计模式中的截图: 例子代码: AbstractProductA类: 1 package com.longsheng.abstractfactory; 2 3 public abstract class AbstractProductA { 4 5 public abstract v

设计模式三—抽象工厂模式

设计模式三-抽象工厂模式 一.定义 抽象工厂模式是工厂方法模式的进一步抽象.如果产品簇中只有一种产品,则退化为工厂方法模式. 二.原理图 三.代码实例 * 苹果和土豆是园丁1的杰作 * 葡萄和西红柿是园丁2的杰作 1.Fruit.java public interface Fruit { /* * 生长 * 收获 * 栽种 */ public void grow(); public void harvest(); public void plant(); } 2.Apple.java publi

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

1.定义 抽象工厂模式为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类. 2.类图 由于类太多就不上源码了~ 最佳实践: 在一个应用中,需要在三个不同平台(Windows.Linux.Android)上运行,通过抽象工厂模式屏蔽掉操作系统对应的影响三个不同操作系统上的软件功能.应用逻辑.UI都应该是非常类似的,唯一不同的是调用不同的工厂方法,由不同的产品类去处理与操作系统交互的信息. 设计模式之抽象工厂模式(Abstract Factory)

C#设计模式之三抽象工厂模式(AbstractFactory)【创建型】

原文:C#设计模式之三抽象工厂模式(AbstractFactory)[创建型] 一.引言 写了3篇有关设计模式的文章了,大家有了些反馈,说能从中学到一些东西,我感到很欣慰,那就继续努力.今天我要写第四个模式了,该模式叫抽象工厂.上一篇文章我们讲了[工厂方法]模式,它是为了解决[简单工厂]模式所面对的问题,它的问题就是:如果我们增加新的产品,工厂类的方法就要修改本身的代码,增加产品越多,其逻辑越复杂,同时这样的修改也是不符合[开放关闭原则OCP],对修改代码关闭,对增加代码开放.为了解决[简单工厂

设计模式---(简单工厂模式,工厂模式,抽象工程模式),单例模式,代理模式,装饰器

简单工厂模式    简单工厂模式并不属于GoF的23种设计模式.     那么为什么我要用工厂模式呢?请看下面的一段程序.  #include  <iostream> using  namespace  std; class  Fruit  { public:     Fruit(string  name)  {         this-­‐>name  =  name;         if  (name  ==  "apple")  {      

设计模式之禅-抽象工程模式

个人blog 此篇博文地址为:http://www.sanyinchenblog.com/?p=268 抽象工厂模式: 为创建一组相关或相互依赖的对象提供一个接口,而且无须指定具体的类. 上一章的的故事背景是女娲造人的故事,抽象工厂模式给出了这样一个背景:女娲造人之后发现人造出的人都是一个类型,没有七情六欲.于是女娲想再造一批人,这次打算造的丰富多彩一点,比如分男和女. 先来看一下uml类图: 我们来看一下NvWa类: public class NvWa { public static void

JAVA设计模式之抽象工厂模式

本文继续介绍23种设计模式系列之抽象工厂模式. 前面已经介绍过简单工厂模式和工厂方法模式,这里继续介绍第三种工厂模式-抽象工厂模式,还是以汽车的制造为例. 例子背景: 随着客户的要求越来越高,宝马车需要不同配置的空调和发动机等配件.于是这个工厂开始生产空调和发动机,用来组装汽车.这时候工厂有两个系列的产品:空调和发动机.宝马320系列配置A型号空调和A型号发动机,宝马230系列配置B型号空调和B型号发动机. 概念: 抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象.比如