设计模式：中介者模式-mediator

用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变他们之间的交互

把原本对象间的耦合，通过一个中间件解除，使得对象解除多对多的关系，变得对象与中间件间有一对一的关系，呈星型结构

中介者模式的优点

适当地使用中介者模式可以避免同事类之间的过度耦合，使得各同事类之间可以相对独立地使用。

使用中介者模式可以将对象间一对多的关联转变为一对一的关联，使对象间的关系易于理解和维护。

使用中介者模式可以将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。

适用场景

  在面向对象编程中，一个类必然会与其他的类发生依赖关系，完全独立的类是没有意义的。一个类同时依赖多个类的情况也相当普遍，既然存在这样的情况，说明，一对多的依赖关系有它的合理性，适当的使用中介者模式可以使原本凌乱的对象关系清晰，但是如果滥用，则可能会带来反的效果。一般来说，只有对于那种同事类之间是网状结构的关系，才会考虑使用中介者模式。可以将网状结构变为星状结构，使同事类之间的关系变的清晰一些。

  中介者模式是一种比较常用的模式，也是一种比较容易被滥用的模式。对于大多数的情况，同事类之间的关系不会复杂到混乱不堪的网状结构，因此，大多数情况下，将对象间的依赖关系封装的同事类内部就可以的，没有必要非引入中介者模式。滥用中介者模式，只会让事情变的更复杂。 

代码

Main

public class Main {

    public static void main(String[] args) {
        Colleague A=new ColleagueA();
        Colleague B=new ColleagueB();

        Mediator m=new MediatorImp(A, B);

        A.setNumber(200,m);
        System.out.println(A.getNumber()+"  "+B.getNumber());


        B.setNumber(200,m);
        System.out.println(A.getNumber()+"  "+B.getNumber());
    }

}

abs:Colleague

public abstract class Colleague {
    protected int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public abstract void setNumber(int number,Mediator mediator);

}

abs:Mediator

public abstract class Mediator {

    protected Colleague A;
    protected Colleague B;
    public Mediator(Colleague A,Colleague B){
        this.A=A;
        this.B=B;
    }
    public abstract void affectA();
    public abstract void affectB();
}

imp:ColleagueA

public class ColleagueA extends Colleague {

    @Override
    public void setNumber(int number, Mediator mediator) {
        this.number=number;
        mediator.affectB();
    }

}

imp:ColleagueB

public class ColleagueB extends Colleague {

    @Override
    public void setNumber(int number, Mediator mediator) {
        this.number=number;
        mediator.affectA();
    }

}

imp:MediatorImp

public class MediatorImp extends Mediator {

    public MediatorImp(Colleague A, Colleague B) {
        super(A, B);
    }

    @Override
    public void affectA() {
        A.setNumber(B.getNumber()*100);
    }

    @Override
    public void affectB() {
        B.setNumber(A.getNumber()/100);
    }

}