2三、行为型-中介者模式（Mediator）

中介者模式(Mediator Pattern)：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不须要显式地相互引用，从而使其耦合松散，并且能够独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

中介者模式包含以下几个角色：

● Mediator（抽象中介者）：它定义一个接口，该接口用于与各同事对象之间进行通讯。
● ConcreteMediator（具体中介者）：它是抽象中介者的子类，经过协调各个同事对象来实现协做行为，它维持了对各个同事对象的引用。
● Colleague（抽象同事类）：它定义各个同事类公有的方法，并声明了一些抽象方法来供子类实现，同时它维持了一个对抽象中介者类的引用，其子类能够经过该引用来与中介者通讯。
● ConcreteColleague（具体同事类）：它是抽象同事类的子类；每个同事对象在须要和其余同事对象通讯时，先与中介者通讯，经过中介者来间接完成与其余同事类的通讯；在具体同事类中实现了在抽象同事类中声明的抽象方法

一、主要优势

(1) 中介者模式简化了对象之间的交互，它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，将本来难以理解的网状结构转换成相对简单的星型结构。
(2) 中介者模式可将各同事对象解耦。中介者有利于各同事之间的松耦合，咱们能够独立的改变和复用每个同事和中介者，增长新的中介者和新的同事类都比较方便，更好地符合“开闭原则”。
(3) 能够减小子类生成，中介者将本来分布于多个对象间的行为集中在一块儿，改变这些行为只需生成新的中介者子类便可，这使各个同事类可被重用，无须对同事类进行扩展。

二、主要缺点

在具体中介者类中包含了大量同事之间的交互细节，可能会致使具体中介者类很是复杂，使得系统难以维护。

三、适用场景

(1) 系统中对象之间存在复杂的引用关系，系统结构混乱且难以理解。
(2) 一个对象因为引用了其余不少对象而且直接和这些对象通讯，致使难以复用该对象。
(3) 想经过一个中间类来封装多个类中的行为，而又不想生成太多的子类。能够经过引入中介者类来实现，在中介者中定义对象交互的公共行为，若是须要改变行为则能够增长新的具体中介者类。

咱们就以租房为例，中介机构充当租房者与房屋全部者之间的中介者

/**
 * 2018/12/6
 * 抽象中介者
 *
 * @author machuanpeng
 */ 
public abstract class Mediator {
    //申明一个联络方法
    public abstract void constact(String message,Person person);
}

/**
 * 2018/12/6
 * 抽象同事对象
 *
 * @author machuanpeng
 */
public abstract class Person {
    
    protected String name;
    protected Mediator mediator;
    
    Person() {}
    
    Person(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }
    
    /**与中介者联系*/
    public void constact(String message){
        mediator.constact(message, this);
    }

    /**获取信息*/
    public void getMessage(String message);
    
    public void getName() {
        return this.name;
	}
    
    public void setName(String name) {
        this.name = name;
	}
    
    public void getMediator() {
        return this.mediator;
	}
    
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
	}
}

/**
 * 2018/12/6
 * 房主
 *
 * @author machuanpeng
 */
public class HouseOwner extends Person{

    HouseOwner(String name, Mediator mediator) {
        super(name, mediator);
    }

    public void getMessage(String message){
        System.out.println("房主:" + name +",得到信息：" + message);
    }
}

/**
 * 2018/12/6
 * 租客
 *
 * @author machuanpeng
 */
public class Renter extends Person{

    Renter(String name, Mediator mediator) {
        super(name, mediator);
    }

    public void getMessage(String message){
        System.out.println("租客:" + name +",得到信息：" + message);
    }
}

/**
 * 2018/12/6
 * 具体中介者对象
 *
 * @author machuanpeng
 */
public class MediatorStructure extends Mediator{
    //首先中介结构必须知道全部房主和租房者的信息
    private HouseOwner houseOwner;
    private Renter renter;
    
    public void constact(String message, Person person) {
        if(person == houseOwner){ 
            //若是是房主，则租房者得到信息
            renter.getMessage(message);
        }else{ 
            //反正则是房主得到信息
            houseOwner.getMessage(message);
        }
    }

    public HouseOwner getHouseOwner() {
        return houseOwner;
    }

    public void setHouseOwner(HouseOwner houseOwner) {
        this.houseOwner = houseOwner;
    }

    public Renter getRenter() {
        return renter;
    }

    public void setRenter(Renter renter) {
        this.renter = renter;
    }
}

测试：

public class Client {
    public static void main(String[] args) {
        //一个房主、一个租房者、一个中介机构
        MediatorStructure mediator = new MediatorStructure();
        
        //房主和租房者只须要知道中介机构便可
        HouseOwner houseOwner = new HouseOwner("张三", mediator);
        Renter renter = new Renter("李四", mediator);
        
        //中介结构要知道房主和租房者
        mediator.setHouseOwner(houseOwner);
        mediator.setRenter(renter);
        
        renter.constact("据说你那里有三室的房主出租.....");
        houseOwner.constact("是的!请问你须要租吗?");
    }
}