锐客网

  1. 首页 > it技术 > >

设计模式 学习 5（）

11个行为模式之5(责任链模式，命令模式，解释器模式，迭代器模式，中介者模式)


责任链模式
问题：
Sunny软件公司承接了某企业SCM(Supply Chain Management，供应链管理)系统的开发任务，其中包含一个采购审批子系统。该企业的采购审批是分级进行的，即根据采购金额的不同由不同层次的主管人员来审批，主任可以审批5万元以下（不包括5万元）的采购单，副董事长可以审批5万元至10万元（不包括10万元）的采购单，董事长可以审批10万元至50万元（不包括50万元）的采购单，50万元及以上的采购单就需要开董事会讨论决定。如图16-1所示：


设计模式 学习 5（）
文章图片



  1. /采购单：请求类
  2. class PurchaseRequest {
  3. private double amount; //采购金额
  4. private int number; //采购单编号
  5. private String purpose; //采购目的
  7. public PurchaseRequest(double amount, int number, String purpose) {
  8. this.amount = amount;
  9. this.number = number;
  10. this.purpose = purpose;
  11. }
  13. public void setAmount(double amount) {
  14. this.amount = amount;
  15. }
  17. public double getAmount() {
  18. return this.amount;
  19. }
  21. public void setNumber(int number) {
  22. this.number = number;
  23. }
  25. public int getNumber() {
  26. return this.number;
  27. }
  29. public void setPurpose(String purpose) {
  30. this.purpose = purpose;
  31. }
  33. public String getPurpose() {
  34. return this.purpose;
  35. }
  36. }
  38. //审批者类：抽象处理者
  39. abstract class Approver {
  40. protected Approver successor; //定义后继对象
  41. protected String name; //审批者姓名
  43. public Approver(String name) {
  44. this.name = name;
  45. }
  47. //设置后继者
  48. public void setSuccessor(Approver successor) {
  49. this.successor = successor;
  50. }
  52. //抽象请求处理方法
  53. public abstract void processRequest(PurchaseRequest request);
  54. }
  56. //主任类：具体处理者
  57. class Director extends Approver {
  58. public Director(String name) {
  59. super(name);
  60. }
  62. //具体请求处理方法
  63. public void processRequest(PurchaseRequest request) {
  64. if (request.getAmount() < 50000) {
  65. System.out.println("主任" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。"); //处理请求
  66. }
  67. else {
  68. this.successor.processRequest(request); //转发请求
  69. }
  70. }
  71. }
  73. //副董事长类：具体处理者
  74. class VicePresident extends Approver {
  75. public VicePresident(String name) {
  76. super(name);
  77. }
  79. //具体请求处理方法
  80. public void processRequest(PurchaseRequest request) {
  81. if (request.getAmount() < 100000) {
  82. System.out.println("副董事长" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。"); //处理请求
  83. }
  84. else {
  85. this.successor.processRequest(request); //转发请求
  86. }
  87. }
  88. }
  90. //董事长类：具体处理者
  91. class President extends Approver {
  92. public President(String name) {
  93. super(name);
  94. }
  96. //具体请求处理方法
  97. public void processRequest(PurchaseRequest request) {
  98. if (request.getAmount() < 500000) {
  99. System.out.println("董事长" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。"); //处理请求
  100. }
  101. else {
  102. this.successor.processRequest(request); //转发请求
  103. }
  104. }
  105. }
  107. //董事会类：具体处理者
  108. class Congress extends Approver {
  109. public Congress(String name) {
  110. super(name);
  111. }
  113. //具体请求处理方法
  114. public void processRequest(PurchaseRequest request) {
  115. System.out.println("召开董事会审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。"); //处理请求
  116. }
  117. }

编写如下客户端测试代码：


  1. class Client {
  2. public static void main(String[] args) {
  3. Approver wjzhang,gyang,jguo,meeting;
  4. wjzhang = new Director("张无忌");
  5. gyang = new VicePresident("杨过");
  6. jguo = new President("郭靖");
  7. meeting = new Congress("董事会");
  9. //创建职责链
  10. wjzhang.setSuccessor(gyang);
  11. gyang.setSuccessor(jguo);
  12. jguo.setSuccessor(meeting);
  14. //创建采购单
  15. PurchaseRequest pr1 = new PurchaseRequest(45000,10001,"购买倚天剑");
  16. wjzhang.processRequest(pr1);
  18. PurchaseRequest pr2 = new PurchaseRequest(60000,10002,"购买《葵花宝典》");
  19. wjzhang.processRequest(pr2);
  21. PurchaseRequest pr3 = new PurchaseRequest(160000,10003,"购买《金刚经》");
  22. wjzhang.processRequest(pr3);
  24. PurchaseRequest pr4 = new PurchaseRequest(800000,10004,"购买桃花岛");
  25. wjzhang.processRequest(pr4);
  26. }
  27. }
命令模式
Sunny软件公司开发人员为公司内部OA系统开发了一个桌面版应用程序，该应用程序为用户提供了一系列自定义功能键，用户可以通过这些功能键来实现一些快捷操作。Sunny软件公司开发人员通过分析，发现不同的用户可能会有不同的使用习惯，在设置功能键的时候每个人都有自己的喜好，例如有的人喜欢将第一个功能键设置为“打开帮助文档”，有的人则喜欢将该功能键设置为“最小化至托盘”，为了让用户能够灵活地进行功能键的设置，开发人员提供了一个“功能键设置”窗口，该窗口界面如图2所示：

设计模式 学习 5（）
文章图片





通过如图2所示界面，用户可以将功能键和相应功能绑定在一起，还可以根据需要来修改功能键的设置，而且系统在未来可能还会增加一些新的功能或功能键。


  1. import java.util.*;
  3. //功能键设置窗口类
  4. class FBSettingWindow {
  5. private String title; //窗口标题
  6. //定义一个ArrayList来存储所有功能键
  7. private ArrayList functionButtons = new ArrayList();
  9. public FBSettingWindow(String title) {
  10. this.title = title;
  11. }
  13. public void setTitle(String title) {
  14. this.title = title;
  15. }
  17. public String getTitle() {
  18. return this.title;
  19. }
  21. public void addFunctionButton(FunctionButton fb) {
  22. functionButtons.add(fb);
  23. }
  25. public void removeFunctionButton(FunctionButton fb) {
  26. functionButtons.remove(fb);
  27. }
  29. //显示窗口及功能键
  30. public void display() {
  31. System.out.println("显示窗口：" + this.title);
  32. System.out.println("显示功能键：");
  33. for (Object obj : functionButtons) {
  34. System.out.println(((FunctionButton)obj).getName());
  35. }
  36. System.out.println("------------------------------");
  37. }
  38. }
  40. //功能键类：请求发送者
  41. class FunctionButton {
  42. private String name; //功能键名称
  43. private Command command; //维持一个抽象命令对象的引用
  45. public FunctionButton(String name) {
  46. this.name = name;
  47. }
  49. public String getName() {
  50. return this.name;
  51. }
  53. //为功能键注入命令
  54. public void setCommand(Command command) {
  55. this.command = command;
  56. }
  58. //发送请求的方法
  59. public void onClick() {
  60. System.out.print("点击功能键：");
  61. command.execute();
  62. }
  63. }
  65. //抽象命令类
  66. abstract class Command {
  67. public abstract void execute();
  68. }
  70. //帮助命令类：具体命令类
  71. class HelpCommand extends Command {
  72. private HelpHandler hhObj; //维持对请求接收者的引用
  74. public HelpCommand() {
  75. hhObj = new HelpHandler();
  76. }
  78. //命令执行方法，将调用请求接收者的业务方法
  79. public void execute() {
  80. hhObj.display();
  81. }
  82. }
  84. //最小化命令类：具体命令类
  85. class MinimizeCommand extends Command {
  86. private WindowHanlder whObj; //维持对请求接收者的引用
  88. public MinimizeCommand() {
  89. whObj = new WindowHanlder();
  90. }
  92. //命令执行方法，将调用请求接收者的业务方法
  93. public void execute() {
  94. whObj.minimize();
  95. }
  96. }
  98. //窗口处理类：请求接收者
  99. class WindowHanlder {
  100. public void minimize() {
  101. System.out.println("将窗口最小化至托盘！");
  102. }
  103. }
  105. //帮助文档处理类：请求接收者
  106. class HelpHandler {
  107. public void display() {
  108. System.out.println("显示帮助文档！");
  109. }
  110. }
为了提高系统的灵活性和可扩展性，我们将具体命令类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：
[java] view plain copy


  1. import javax.xml.parsers.*;
  2. import org.w3c.dom.*;
  3. import org.xml.sax.SAXException;
  4. import java.io.*;
  6. public class XMLUtil {
  7. //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象，可以通过参数的不同返回不同类名节点所对应的实例
  8. public static Object getBean(int i) {
  9. try {
  10. //创建文档对象
  11. DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
  12. DocumentBuilder builder = dFactory.newDocumentBuilder();
  13. Document doc;
  14. doc = builder.parse(new File("config.xml"));
  16. //获取包含类名的文本节点
  17. NodeList nl = doc.getElementsByTagName("className");
  18. Node classNode = null;
  19. if (0 == i) {
  20. classNode = nl.item(0).getFirstChild();
  21. }
  22. else {
  23. classNode = nl.item(1).getFirstChild();
  24. }
  26. String cName = classNode.getNodeValue();
  28. //通过类名生成实例对象并将其返回
  29. Class c = Class.forName(cName);
  30. Object obj = c.newInstance();
  31. return obj;
  32. }
  33. catch(Exception e){
  34. e.printStackTrace();
  35. return null;
  36. }
  37. }
  38. }
配置文件config.xml中存储了具体建造者类的类名，代码如下所示：
[java] view plain copy


  3. HelpCommand
  4. MinimizeCommand
编写如下客户端测试代码：


  1. class Client {
  2. public static void main(String args[]) {
  3. FBSettingWindow fbsw = new FBSettingWindow("功能键设置");
  5. FunctionButton fb1,fb2;
  6. fb1 = new FunctionButton("功能键1");
  7. fb2 = new FunctionButton("功能键1");
  9. Command command1,command2;
  10. //通过读取配置文件和反射生成具体命令对象
  11. command1 = (Command)XMLUtil.getBean(0);
  12. command2 = (Command)XMLUtil.getBean(1);
  14. //将命令对象注入功能键
  15. fb1.setCommand(command1);
  16. fb2.setCommand(command2);
  18. fbsw.addFunctionButton(fb1);
  19. fbsw.addFunctionButton(fb2);
  20. fbsw.display();
  22. //调用功能键的业务方法
  23. fb1.onClick();
  24. fb2.onClick();
  25. }
  26. }






解释器模式


Sunny软件公司欲为某玩具公司开发一套机器人控制程序，在该机器人控制程序中包含一些简单的英文控制指令，每一个指令对应一个表达式(expression)，该表达式可以是简单表达式也可以是复合表达式，每一个简单表达式由移动方向(direction)，移动方式(action)和移动距离(distance)三部分组成，其中移动方向包括上(up)、下(down)、左(left)、右(right)；移动方式包括移动(move)和快速移动(run)；移动距离为一个正整数。两个表达式之间可以通过与(and)连接，形成复合(composite)表达式。
用户通过对图形化的设置界面进行操作可以创建一个机器人控制指令，机器人在收到指令后将按照指令的设置进行移动，例如输入控制指令：up move 5，则“向上移动5个单位”；输入控制指令：downrun 10 and left move 20，则“向下快速移动10个单位再向左移动20个单位”。




expression ::= direction action distance | composite //表达式
composite ::= expression 'and' expression //复合表达式
direction ::= 'up' | 'down' | 'left' | 'right' //移动方向
action ::= 'move' | 'run' //移动方式
distance ::= an integer //移动距离


  1. //注：本实例对机器人控制指令的输出结果进行模拟，将英文指令翻译为中文指令，实际情况是调用不同的控制程序进行机器人的控制，包括对移动方向、方式和距离的控制等
  2. import java.util.*;
  4. //抽象表达式
  5. abstract class AbstractNode {
  6. public abstract String interpret();
  7. }
  9. //And解释：非终结符表达式
  10. class AndNode extends AbstractNode {
  11. private AbstractNode left; //And的左表达式
  12. private AbstractNode right; //And的右表达式
  14. public AndNode(AbstractNode left, AbstractNode right) {
  15. this.left = left;
  16. this.right = right;
  17. }
  19. //And表达式解释操作
  20. public String interpret() {
  21. return left.interpret() + "再" + right.interpret();
  22. }
  23. }
  25. //简单句子解释：非终结符表达式
  26. class SentenceNode extends AbstractNode {
  27. private AbstractNode direction;
  28. private AbstractNode action;
  29. private AbstractNode distance;
  31. public SentenceNode(AbstractNode direction,AbstractNode action,AbstractNode distance) {
  32. this.direction = direction;
  33. this.action = action;
  34. this.distance = distance;
  35. }
  37. //简单句子的解释操作
  38. public String interpret() {
  39. return direction.interpret() + action.interpret() + distance.interpret();
  40. }
  41. }
  43. //方向解释：终结符表达式
  44. class DirectionNode extends AbstractNode {
  45. private String direction;
  47. public DirectionNode(String direction) {
  48. this.direction = direction;
  49. }
  51. //方向表达式的解释操作
  52. public String interpret() {
  53. if (direction.equalsIgnoreCase("up")) {
  54. return "向上";
  55. }
  56. else if (direction.equalsIgnoreCase("down")) {
  57. return "向下";
  58. }
  59. else if (direction.equalsIgnoreCase("left")) {
  60. return "向左";
  61. }
  62. else if (direction.equalsIgnoreCase("right")) {
  63. return "向右";
  64. }
  65. else {
  66. return "无效指令";
  67. }
  68. }
  69. }
  71. //动作解释：终结符表达式
  72. class ActionNode extends AbstractNode {
  73. private String action;
  75. public ActionNode(String action) {
  76. this.action = action;
  77. }
  79. //动作（移动方式）表达式的解释操作
  80. public String interpret() {
  81. if (action.equalsIgnoreCase("move")) {
  82. return "移动";
  83. }
  84. else if (action.equalsIgnoreCase("run")) {
  85. return "快速移动";
  86. }
  87. else {
  88. return "无效指令";
  89. }
  90. }
  91. }
  93. //距离解释：终结符表达式
  94. class DistanceNode extends AbstractNode {
  95. private String distance;
  97. public DistanceNode(String distance) {
  98. this.distance = distance;
  99. }
  101. //距离表达式的解释操作
  102. public String interpret() {
  103. return this.distance;
  104. }
  105. }
  107. //指令处理类：工具类
  108. class InstructionHandler {
  109. private String instruction;
  110. private AbstractNode node;
  112. public void handle(String instruction) {
  113. AbstractNode left = null, right = null;
  114. AbstractNode direction = null, action = null, distance = null;
  115. Stack stack = new Stack(); //声明一个栈对象用于存储抽象语法树
  116. String[] words = instruction.split(" "); //以空格分隔指令字符串
  117. for (int i = 0; i < words.length; i++) {
  118. //本实例采用栈的方式来处理指令，如果遇到“and”，则将其后的三个单词作为三个终结符表达式连成一个简单句子SentenceNode作为“and”的右表达式，而将从栈顶弹出的表达式作为“and”的左表达式，最后将新的“and”表达式压入栈中。if (words[i].equalsIgnoreCase("and")) {
  119. left = (AbstractNode)stack.pop(); //弹出栈顶表达式作为左表达式
  120. String word1= words[++i];
  121. direction = new DirectionNode(word1);
  122. String word2 = words[++i];
  123. action = new ActionNode(word2);
  124. String word3 = words[++i];
  125. distance = new DistanceNode(word3);
  126. right = new SentenceNode(direction,action,distance); //右表达式
  127. stack.push(new AndNode(left,right)); //将新表达式压入栈中
  128. }
  129. //如果是从头开始进行解释，则将前三个单词组成一个简单句子SentenceNode并将该句子压入栈中
  130. else {
  131. String word1 = words[i];
  132. direction = new DirectionNode(word1);
  133. String word2 = words[++i];
  134. action = new ActionNode(word2);
  135. String word3 = words[++i];
  136. distance = new DistanceNode(word3);
  137. left = new SentenceNode(direction,action,distance);
  138. stack.push(left); //将新表达式压入栈中
  139. }
  140. }
  141. this.node = (AbstractNode)stack.pop(); //将全部表达式从栈中弹出
  142. }
  144. public String output() {
  145. String result = node.interpret(); //解释表达式
  146. return result;
  147. }
  148. }
工具类InstructionHandler用于对输入指令进行处理，将输入指令分割为字符串数组，将第1个、第2个和第3个单词组合成一个句子，并存入栈中；如果发现有单词“and”，则将“and”后的第1个、第2个和第3个单词组合成一个新的句子作为“and”的右表达式，并从栈中取出原先所存句子作为左表达式，然后组合成一个And节点存入栈中。依此类推，直到整个指令解析结束。
编写如下客户端测试代码：
[java] view plain copy


  1. class Client {
  2. public static void main(String args[]) {
  3. String instruction = "up move 5 and down run 10 and left move 5";
  4. InstructionHandler handler = new InstructionHandler();
  5. handler.handle(instruction);
  6. String outString;
  7. outString = handler.output();
  8. System.out.println(outString);
  9. }
  10. }






迭代器模式
  1. //在本实例中，为了详细说明自定义迭代器的实现过程，我们没有使用JDK中内置的迭代器，事实上，JDK内置迭代器已经实现了对一个List对象的正向遍历
  2. import java.util.*;
  4. //抽象聚合类
  5. abstract class AbstractObjectList {
  6. protected List objects = new ArrayList();
  8. public AbstractObjectList(List objects) {
  9. this.objects = objects;
  10. }
  12. public void addObject(Object obj) {
  13. this.objects.add(obj);
  14. }
  16. public void removeObject(Object obj) {
  17. this.objects.remove(obj);
  18. }
  20. public List getObjects() {
  21. return this.objects;
  22. }
  24. //声明创建迭代器对象的抽象工厂方法
  25. public abstract AbstractIterator createIterator();
  26. }
  28. //商品数据类：具体聚合类
  29. class ProductList extends AbstractObjectList {
  30. public ProductList(List products) {
  31. super(products);
  32. }
  34. //实现创建迭代器对象的具体工厂方法
  35. public AbstractIterator createIterator() {
  36. return new ProductIterator(this);
  37. }
  38. }
  40. //抽象迭代器
  41. interface AbstractIterator {
  42. public void next(); //移至下一个元素
  43. public boolean isLast(); //判断是否为最后一个元素
  44. public void previous(); //移至上一个元素
  45. public boolean isFirst(); //判断是否为第一个元素
  46. public Object getNextItem(); //获取下一个元素
  47. public Object getPreviousItem(); //获取上一个元素
  48. }
  50. //商品迭代器：具体迭代器
  51. class ProductIterator implements AbstractIterator {
  52. private ProductList productList;
  53. private List products;
  54. private int cursor1; //定义一个游标，用于记录正向遍历的位置
  55. private int cursor2; //定义一个游标，用于记录逆向遍历的位置
  57. public ProductIterator(ProductList list) {
  58. this.productList = list;
  59. this.products = list.getObjects(); //获取集合对象
  60. cursor1 = 0; //设置正向遍历游标的初始值
  61. cursor2 = products.size() -1; //设置逆向遍历游标的初始值
  62. }
  64. public void next() {
  65. if(cursor1 < products.size()) {
  66. cursor1++;
  67. }
  68. }
  70. public boolean isLast() {
  71. return (cursor1 == products.size());
  72. }
  74. public void previous() {
  75. if (cursor2 > -1) {
  76. cursor2--;
  77. }
  78. }
  80. public boolean isFirst() {
  81. return (cursor2 == -1);
  82. }
  84. public Object getNextItem() {
  85. return products.get(cursor1);
  86. }
  88. public Object getPreviousItem() {
  89. return products.get(cursor2);
  90. }
  91. }
    92. 编写如下客户端测试代码：


    1. class Client {
    2. public static void main(String args[]) {
    3. List products = new ArrayList();
    4. products.add("倚天剑");
    5. products.add("屠龙刀");
    6. products.add("断肠草");
    7. products.add("葵花宝典");
    8. products.add("四十二章经");
    10. AbstractObjectList list;
    11. AbstractIterator iterator;
    13. list = new ProductList(products); //创建聚合对象
    14. iterator = list.createIterator(); //创建迭代器对象
    16. System.out.println("正向遍历：");
    17. while(!iterator.isLast()) {
    18. System.out.print(iterator.getNextItem() + "，");
    19. iterator.next();
    20. }
    21. System.out.println();
    22. System.out.println("-----------------------------");
    23. System.out.println("逆向遍历：");
    24. while(!iterator.isFirst()) {
    25. System.out.print(iterator.getPreviousItem() + "，");
    26. iterator.previous();
    27. }
    28. }
    29. ｝






    使用内部类实现迭代器


    1. //商品数据类：具体聚合类
    2. class ProductList extends AbstractObjectList {
    3. public ProductList(List products) {
    4. super(products);
    5. }
    7. public AbstractIterator createIterator() {
    8. return new ProductIterator();
    9. }
    11. //商品迭代器：具体迭代器，内部类实现
    12. private class ProductIterator implements AbstractIterator {
    13. private int cursor1;
    14. private int cursor2;
    16. public ProductIterator() {
    17. cursor1 = 0;
    18. cursor2 = objects.size() -1;
    19. }
    21. public void next() {
    22. if(cursor1 < objects.size()) {
    23. cursor1++;
    24. }
    25. }
    27. public boolean isLast() {
    28. return (cursor1 == objects.size());
    29. }
    31. public void previous() {
    32. if(cursor2 > -1) {
    33. cursor2--;
    34. }
    35. }
    37. public boolean isFirst() {
    38. return (cursor2 == -1);
    39. }
    41. public Object getNextItem() {
    42. return objects.get(cursor1);
    43. }
    45. public Object getPreviousItem() {
    46. return objects.get(cursor2);
    47. }
    48. }
    49. }
    【设计模式 学习 5（）】





    中介者模式


    Sunny软件公司欲开发一套CRM系统，其中包含一个客户信息管理模块，所设计的“客户信息管理窗口”界面效果图如图20-2所示：Sunny公司开发人员通过分析发现，在图20-2中，界面组件之间存在较为复杂的交互关系：如果删除一个客户，要在客户列表(List)中删掉对应的项，客户选择组合框(ComboBox)中客户名称也将减少一个；如果增加一个客户信息，客户列表中需增加一个客户，且组合框中也将增加一项。如果实现界面组件之间的交互是Sunny公司开发人员必须面对的一个问题？

    设计模式 学习 5（）
    文章图片







    解决：



    设计模式 学习 5（）
    文章图片





    1. abstract class Mediator {
    2. public abstract void componentChanged(Component c);
    3. }
    5. //具体中介者
    6. class ConcreteMediator extends Mediator {
    7. //维持对各个同事对象的引用
    8. public Button addButton;
    9. public List list;
    10. public TextBox userNameTextBox;
    11. public ComboBox cb;
    13. //封装同事对象之间的交互
    14. public void componentChanged(Component c) {
    15. //单击按钮
    16. if(c == addButton) {
    17. System.out.println("--单击增加按钮--");
    18. list.update();
    19. cb.update();
    20. userNameTextBox.update();
    21. }
    22. //从列表框选择客户
    23. else if(c == list) {
    24. System.out.println("--从列表框选择客户--");
    25. cb.select();
    26. userNameTextBox.setText();
    27. }
    28. //从组合框选择客户
    29. else if(c == cb) {
    30. System.out.println("--从组合框选择客户--");
    31. cb.select();
    32. userNameTextBox.setText();
    33. }
    34. }
    35. }
    37. //抽象组件类：抽象同事类
    38. abstract class Component {
    39. protected Mediator mediator;
    41. public void setMediator(Mediator mediator) {
    42. this.mediator = mediator;
    43. }
    45. //转发调用
    46. public void changed() {
    47. mediator.componentChanged(this);
    48. }
    50. public abstract void update();
    51. }
    53. //按钮类：具体同事类
    54. class Button extends Component {
    55. public void update() {
    56. //按钮不产生交互
    57. }
    58. }
    60. //列表框类：具体同事类
    61. class List extends Component {
    62. public void update() {
    63. System.out.println("列表框增加一项：张无忌。");
    64. }
    66. public void select() {
    67. System.out.println("列表框选中项：小龙女。");
    68. }
    69. }
    71. //组合框类：具体同事类
    72. class ComboBox extends Component {
    73. public void update() {
    74. System.out.println("组合框增加一项：张无忌。");
    75. }
    77. public void select() {
    78. System.out.println("组合框选中项：小龙女。");
    79. }
    80. }
    82. //文本框类：具体同事类
    83. class TextBox extends Component {
    84. public void update() {
    85. System.out.println("客户信息增加成功后文本框清空。");
    86. }
    88. public void setText() {
    89. System.out.println("文本框显示：小龙女。");
    90. }
    91. }

    编写如下客户端测试代码：


    1. class Client {
    2. public static void main(String args[]) {
    3. //定义中介者对象
    4. ConcreteMediator mediator;
    5. mediator = new ConcreteMediator();
    7. //定义同事对象
    8. Button addBT = new Button();
    9. List list = new List();
    10. ComboBox cb = new ComboBox();
    11. TextBox userNameTB = new TextBox();
    13. addBT.setMediator(mediator);
    14. list.setMediator(mediator);
    15. cb.setMediator(mediator);
    16. userNameTB.setMediator(mediator);
    18. mediator.addButton = addBT;
    19. mediator.list = list;
    20. mediator.cb = cb;
    21. mediator.userNameTextBox = userNameTB;
    23. addBT.changed();
    24. System.out.println("-----------------------------");
    25. list.changed();
    26. }
    27. }





      推荐阅读


      上一篇：Java异步HTTP请求

      下一篇：codeforces Round#377