Java学习-设计模式-中介者模式

Java学习-设计模式-中介者模式

概念：

中介者模式是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

优点： 1、降低了类的复杂度，将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。

**缺点：**中介者会庞大，变得复杂难以维护。

使用场景： 1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。 2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

理解：

就拿打牌的输赢来说，现在假设只有 A 和 B 在打牌，那么输赢都是 A、B对象类里面的余额属性发生变化，对于这个我们一般定义一个方法来实现余额的变化，现在假设多了一个 C ，那个就要在对象A、B中加上与C相关的修改余额的方法，C中要写关于 A、B的方法，如果人数一多，修改的对象类就变得很多，类也变得很臃肿。

但是，余额的变化其实都类似，只是对象不同，执行的操作的类似，所以我们把这部分操作拿出来，所有的余额操作都由这个类来操作，放到一个类中，这个类就是中介类。

查看过网上很多笔记，但是都是一个对象对一个对象的，感觉真的遇到这个场景时，不会这样写，就算不用中介者模式，我感觉应该是这样的：
1. 新建一个抽象的牌友类，包括一个余额的属性，构造方法中初始化这个属性，并提供这个属性的get和set方法，在创建一个抽象的资金改变方法，入参有一个改变的金额，还有一个类型为抽象的牌友类
2. 新建一个牌友类继承长线的牌友类，重写抽象方法，抽象方法首先修改自己的余额，然后调用入参的对象类改变其余额，完成变化。
3. 测试，新建三个牌友类，调用赢钱那个人的余额改变方法，传入对应输钱人的对象。
感觉这样也成，但是这样的话，多个对象就相互耦合了。

使用中介者模式
1. 新建一个抽象的牌友类，包括一个余额的属性，构造方法中初始化这个属性，并提供这个属性的get和set方法，在创建一个抽象的资金改变方法，入参有一个改变的金额，还有一个类型为抽象的中介类
2. 新建一个牌友类继承长线的牌友类，重写抽象方法，在方法中调用入参的中介者对象类处理
3. 新建一个中介者的抽象类，包含两个类型为抽象的牌友类 A 、B ，并在构造方法中初始化好，还包含一个抽象方法，方法中入参一个变化的余额
4. 新建一个中介者实现类实现这个抽象的中介类，重写抽象方法，根据相应关系修改对应对象的余额值
5. 测试，新建两个牌友类，初始化好两者的初始余额，使用这两个对象初始化好中介者对象，调用对应的余额变化方法改变余额。

注意：假设现在多来了一个人（即新增一个对象），不是在中介者类中添加方法，而是新建好增加的对象，将这个新增加的对象与A一起再初始化好一个中介者对象。实现B、C关系也一样。

示例：

package Practices.Mode.Mediator_Pattern;
// 1. 新建一个抽象的牌友类
public abstract class User {
    protected int money;

    public User(int money) {
        this.money = money;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public abstract void changemoney(int cmoney,AbstractMediator mediator);
}

package Practices.Mode.Mediator_Pattern;
// 2. 创建一个牌友类的实体类
public class CardUser extends User {
    public CardUser(int money) {
        super(money);
    }

    public void changemoney(int cmoney, AbstractMediator mediator) {
        mediator.WinMoney(cmoney,this);
    }
}

package Practices.Mode.Mediator_Pattern;
// 3. 新建一个抽象的中介者类
public abstract class AbstractMediator {
    protected User userA;
    protected User userB;

    public AbstractMediator(User userA, User userB) {
        this.userA = userA;
        this.userB = userB;
    }

    public abstract void WinMoney(int cmoney,User user);

}

package Practices.Mode.Mediator_Pattern;
// 4. 新建一个中介者实体类
public class AchiveMediator extends AbstractMediator {
    public AchiveMediator(User userA, User userB) {
        super(userA, userB);
    }

    public void WinMoney(int cmoney, User user) {
        if(user == userA){
            userA.money += cmoney;
            userB.money -= cmoney;
            System.out.println("A赢"+cmoney+",当前A的余额为"+userA.money+"，当前B的余额为"+userB.money);
        }else{
            userB.money += cmoney;
            userA.money -= cmoney;
            System.out.println("B赢"+cmoney+",当前A的余额为"+userA.money+"，当前B的余额为"+userB.money);
        }
    }
}

package Practices.Mode.Mediator_Pattern;
// 5.测试
public class Test_Mian {
    public static void main(String[] args) {
        User userA = new CardUser(5000);
        User userB = new CardUser(5000);

        AbstractMediator mediator = new AchiveMediator(userA,userB);

        userA.changemoney(500,mediator);
        userB.changemoney(200,mediator);
    }
}