0%

设计模式之行为型模式(五):中介者模式

1. 中介者模式概述

  • 概念

    • 定义一个中介对象来封装一系列对象之间的交互,使原有对象之间的耦合松散,且可以独立地改变它们之间的交互
    • Mediator 的意思是调解员,所以中介者模式又称调解者模式
  • 缺点

    • 由于将所有的职责都移到了中介者类,即中介类需要处理所有类之间的协调工作,可能会使中介者演变成一个超级类
  • Demo

    • 玩家类

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      class Player {
      // 初始资金 100 元
      public int money = 100;

      public void win(Player player, int money) {
      // 输钱的人扣减相应的钱
      player.money -= money;
      // 自己的余额增加
      this.money += money;
      }
      }
    • 客户端

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      public class Client {
      @Test
      public void test() {
      Player player1 = new Player();
      Player player2 = new Player();
      Player player3 = new Player();
      Player player4 = new Player();
      // player1 赢了 player3 5 元
      player1.win(player3, 5);
      // player2 赢了 player1 10 元
      player2.win(player1, 10);
      // player2 赢了 player4 10 元
      player2.win(player4, 10);
      // player4 赢了 player3 7 元
      player4.win(player3, 7);

      // 输出:四人剩余的钱:105,120,88,97
      System.out.println("四人剩余的钱:" + player1.money + "," + player2.money + "," + player3.money + "," + player4.money);
      }
      }
    • 中介者类

      1
      2
      3
      class Group {
      public int money;
      }
    • 修改玩家类

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      class Player {
      public int money = 100;
      public Group group;

      public Player(Group group) {
      this.group = group;
      }

      public void change(int money) {
      // 输了钱将钱发到群里 或 在群里领取自己赢的钱
      group.money += money;
      // 自己的余额改变
      this.money += money;
      }
      }
    • 修改客户端

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      public class Client {
      @Test
      public void test(){
      Group group = new Group();
      Player player1 = new Player(group);
      Player player2 = new Player(group);
      Player player3 = new Player(group);
      Player player4 = new Player(group);
      // player1 赢了 5 元
      player1.change(5);
      // player2 赢了 20 元
      player2.change(20);
      // player3 输了 12 元
      player3.change(-12);
      // player4 输了 3 元
      player4.change(-3);

      // 输出:四人剩余的钱:105,120,88,97
      System.out.println("四人剩余的钱:" + player1.money + "," + player2.money + "," + player3.money + "," + player4.money);
      }
      }
      • 不足之处:忽略了一个前提,中介者的钱不可以为负数。即输家必须先将钱发给中介者,赢家再去中介者处领钱。这个功能可以用在Java 多线程王国奇遇记中学到的 wait/notify 机制完成,与中介者无关
-------------------- 本文结束感谢您的阅读 --------------------