zoukankan      html  css  js  c++  java

  • 七.抽象工厂模式

    前面介绍的工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。

    同种类称为同等级，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如农场里既养动物又种植物，电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

    本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，图 1 所示的是海尔工厂和 TCL 工厂所生产的电视机与空调对应的关系图。

    电器工厂的产品等级与产品族
    图1 电器工厂的产品等级与产品族

    模式的定义与特点

    抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

    抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

    使用抽象工厂模式一般要满足以下条件。

    • 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
    • 系统一次只可能消费其中某一族产品，即同族的产品一起使用。


    抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

    • 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
    • 当增加一个新的产品族时不需要修改原代码，满足开闭原则。


    其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

    模式的结构与实现

    抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

    1. 模式的结构

    抽象工厂模式的主要角色如下。

    1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
    2. 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
    3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
    4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。


    抽象工厂模式的结构图如图 2 所示。

    抽象工厂模式的结构图
    图2 抽象工厂模式的结构图

    2. 模式的实现

    从图 2 可以看出抽象工厂模式的结构同工厂方法模式的结构相似，不同的是其产品的种类不止一个，所以创建产品的方法也不止一个。下面给出抽象工厂和具体工厂的代码。

    (1) 抽象工厂：提供了产品的生成方法。

    1. interface AbstractFactory
    2. {
    3. public Product1 newProduct1();
    4. public Product2 newProduct2();
    5. }


    (2) 具体工厂：实现了产品的生成方法。

    1. class ConcreteFactory1 implements AbstractFactory
    2. {
    3. public Product1 newProduct1()
    4. {
    5. System.out.println("具体工厂 1 生成-->具体产品 11...");
    6. return new ConcreteProduct11();
    7. }
    8. public Product2 newProduct2()
    9. {
    10. System.out.println("具体工厂 1 生成-->具体产品 21...");
    11. return new ConcreteProduct21();
    12. }
    13. }

    模式的应用实例

    【例1】用抽象工厂模式设计农场类。

    分析：农场中除了像畜牧场一样可以养动物，还可以培养植物，如养马、养牛、种菜、种水果等，所以本实例比前面介绍的畜牧场类复杂，必须用抽象工厂模式来实现。

    本例用抽象工厂模式来设计两个农场，一个是韶关农场用于养牛和种菜，一个是上饶农场用于养马和种水果，可以在以上两个农场中定义一个生成动物的方法 newAnimal() 和一个培养植物的方法 newPlant()。

    对马类、牛类、蔬菜类和水果类等具体产品类，由于要显示它们的图像（点此下载图片），所以它们的构造函数中用到了 JPanel、JLabel 和 ImageIcon 等组件，并定义一个 show() 方法来显示它们。

    客户端程序通过对象生成器类 ReadXML 读取 XML 配置文件中的数据来决定养什么动物和培养什么植物（点此下载 XML 文件）。其结构图如图 3 所示。

    农场类的结构图
    图3 农场类的结构图


    程序代码如下：

    1. package AbstractFactory;
    2. import java.awt.*;
    3. import javax.swing.*;
    4. public class FarmTest
    5. {
    6. public static void main(String[] args)
    7. {
    8. try
    9. {
    10. Farm f;
    11. Animal a;
    12. Plant p;
    13. f=(Farm) ReadXML.getObject();
    14. a=f.newAnimal();
    15. p=f.newPlant();
    16. a.show();
    17. p.show();
    18. }
    19. catch(Exception e)
    20. {
    21. System.out.println(e.getMessage());
    22. }
    23. }
    24. }
    25. //抽象产品：动物类
    26. interface Animal
    27. {
    28. public void show();
    29. }
    30. //具体产品：马类
    31. class Horse implements Animal
    32. {
    33. JScrollPane sp;
    34. JFrame jf=new JFrame("抽象工厂模式测试");
    35. public Horse()
    36. {
    37. Container contentPane=jf.getContentPane();
    38. JPanel p1=new JPanel();
    39. p1.setLayout(new GridLayout(1,1));
    40. p1.setBorder(BorderFactory.createTitledBorder("动物：马"));
    41. sp=new JScrollPane(p1);
    42. contentPane.add(sp, BorderLayout.CENTER);
    43. JLabel l1=new JLabel(new ImageIcon("src/A_Horse.jpg"));
    44. p1.add(l1);
    45. jf.pack();
    46. jf.setVisible(false);
    47. jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭
    48. }
    49. public void show()
    50. {
    51. jf.setVisible(true);
    52. }
    53. }
    54. //具体产品：牛类
    55. class Cattle implements Animal
    56. {
    57. JScrollPane sp;
    58. JFrame jf=new JFrame("抽象工厂模式测试");
    59. public Cattle() {
    60. Container contentPane=jf.getContentPane();
    61. JPanel p1=new JPanel();
    62. p1.setLayout(new GridLayout(1,1));
    63. p1.setBorder(BorderFactory.createTitledBorder("动物：牛"));
    64. sp=new JScrollPane(p1);
    65. contentPane.add(sp, BorderLayout.CENTER);
    66. JLabel l1=new JLabel(new ImageIcon("src/A_Cattle.jpg"));
    67. p1.add(l1);
    68. jf.pack();
    69. jf.setVisible(false);
    70. jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭
    71. }
    72. public void show()
    73. {
    74. jf.setVisible(true);
    75. }
    76. }
    77. //抽象产品：植物类
    78. interface Plant
    79. {
    80. public void show();
    81. }
    82. //具体产品：水果类
    83. class Fruitage implements Plant
    84. {
    85. JScrollPane sp;
    86. JFrame jf=new JFrame("抽象工厂模式测试");
    87. public Fruitage()
    88. {
    89. Container contentPane=jf.getContentPane();
    90. JPanel p1=new JPanel();
    91. p1.setLayout(new GridLayout(1,1));
    92. p1.setBorder(BorderFactory.createTitledBorder("植物：水果"));
    93. sp=new JScrollPane(p1);
    94. contentPane.add(sp, BorderLayout.CENTER);
    95. JLabel l1=new JLabel(new ImageIcon("src/P_Fruitage.jpg"));
    96. p1.add(l1);
    97. jf.pack();
    98. jf.setVisible(false);
    99. jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭
    100. }
    101. public void show()
    102. {
    103. jf.setVisible(true);
    104. }
    105. }
    106. //具体产品：蔬菜类
    107. class Vegetables implements Plant
    108. {
    109. JScrollPane sp;
    110. JFrame jf=new JFrame("抽象工厂模式测试");
    111. public Vegetables()
    112. {
    113. Container contentPane=jf.getContentPane();
    114. JPanel p1=new JPanel();
    115. p1.setLayout(new GridLayout(1,1));
    116. p1.setBorder(BorderFactory.createTitledBorder("植物：蔬菜"));
    117. sp=new JScrollPane(p1);
    118. contentPane.add(sp, BorderLayout.CENTER);
    119. JLabel l1=new JLabel(new ImageIcon("src/P_Vegetables.jpg"));
    120. p1.add(l1);
    121. jf.pack();
    122. jf.setVisible(false);
    123. jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//用户点击窗口关闭
    124. }
    125. public void show()
    126. {
    127. jf.setVisible(true);
    128. }
    129. }
    130. //抽象工厂：农场类
    131. interface Farm
    132. {
    133. public Animal newAnimal();
    134. public Plant newPlant();
    135. }
    136. //具体工厂：韶关农场类
    137. class SGfarm implements Farm
    138. {
    139. public Animal newAnimal()
    140. {
    141. System.out.println("新牛出生！");
    142. return new Cattle();
    143. }
    144. public Plant newPlant()
    145. {
    146. System.out.println("蔬菜长成！");
    147. return new Vegetables();
    148. }
    149. }
    150. //具体工厂：上饶农场类
    151. class SRfarm implements Farm
    152. {
    153. public Animal newAnimal()
    154. {
    155. System.out.println("新马出生！");
    156. return new Horse();
    157. }
    158. public Plant newPlant()
    159. {
    160. System.out.println("水果长成！");
    161. return new Fruitage();
    162. }
    163. }
    1. package AbstractFactory;
    2. import javax.xml.parsers.*;
    3. import org.w3c.dom.*;
    4. import java.io.*;
    5. class ReadXML
    6. {
    7. public static Object getObject()
    8. {
    9. try
    10. {
    11. DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
    12. DocumentBuilder builder=dFactory.newDocumentBuilder();
    13. Document doc;
    14. doc=builder.parse(new File("src/AbstractFactory/config.xml"));
    15. NodeList nl=doc.getElementsByTagName("className");
    16. Node classNode=nl.item(0).getFirstChild();
    17. String cName="AbstractFactory."+classNode.getNodeValue();
    18. System.out.println("新类名："+cName);
    19. Class<?> c=Class.forName(cName);
    20. Object obj=c.newInstance();
    21. return obj;
    22. }
    23. catch(Exception e)
    24. {
    25. e.printStackTrace();
    26. return null;
    27. }
    28. }
    29. }


    程序运行结果如图 4 所示。

    农场养殖的运行结果
    图4 农场养殖的运行结果

    模式的应用场景

    抽象工厂模式最早的应用是用于创建属于不同操作系统的视窗构件。如 java 的 AWT 中的 Button 和 Text 等构件在 Windows 和 UNIX 中的本地实现是不同的。

    抽象工厂模式通常适用于以下场景：

    1. 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
    2. 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
    3. 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

    模式的扩展

    抽象工厂模式的扩展有一定的“开闭原则”倾斜性：

    1. 当增加一个新的产品族时只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则。
    2. 当产品族中需要增加一个新种类的产品时，则所有的工厂类都需要进行修改，不满足开闭原则。


    另一方面，当系统中只存在一个等级结构的产品时，抽象工厂模式将退化到工厂方法模式。
  • 相关阅读:
    Theano入门笔记1：Theano中的Graph Structure
    [译博文]CUDA是什么
    一天一经典Efficient Estimation of Word Representations in Vector Space
    Generating a Random Sample from discrete probability distribution
    关于representation的理解
    git代码管理——克隆项目到本地仓库及上传本地项目到仓库
    yum管理——linux字符界面安装图形化及两种界面的切换（3）
    yum管理——yum常用配置（2）
    yum管理——搭建iso镜像私有yum源仓库（1）
    apche编译安装
  • 原文地址：https://www.cnblogs.com/chenhg/p/13491447.html
Copyright © 2011-2022 走看看