中介者模式

/**
 * 中介者模式
 * 个人理解：将多个交互对象进行解耦，通过一个中间者封装所有对象，对象之间交换靠中间者完成
 *  中介者要封装所有元素对象，元素对象要依赖中介者
 *  组件：抽象中介类（Mediator）、具体中介类（ConcreteMediator）、抽象同事类（Colleague）、具体同事类（ConcreteColleague）、客户端（Client）
 *  场景举例：对象之间存在复杂的交换，如租房
 *  优点：减少交互，解耦
 *  缺点：元素对象交换细节太多，可能造成中介者类复杂
 */
public class DesignerPattern {
    public static void main(String[] args) {
        Mediator mediator = new Mediator();
        Order order = new Order("Tom", mediator);
        mediator.setOrder(order);
        Seller seller = new Seller("Jerry", mediator);
        mediator.setSeller(seller);
        order.request();
        seller.request();
    }
}

abstract class Person {
    protected String name;
    protected Mediator mediator;

    public Person(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

}

class Order extends Person {

    public Order(String name, Mediator mediator) {
        super(name, mediator);
    }

    public void request() {
        System.out.println(name + " want a house.");
        mediator.operate(this);
    }

    public void response() {
        System.out.println("Good, " + name + " want a car.");
    }
}

class Seller extends Person {

    public Seller(String name, Mediator mediator) {
        super(name, mediator);
    }

    public void request() {
        System.out.println(name + " have a car.");
        mediator.operate(this);
    }

    public void response() {
        System.out.println("Good, " + name + " have a house.");
    }
}

class Mediator {
    private Order order;

    private Seller seller;

    public void operate(Person person) {
        //doSomething
        if (person == seller) {
            order.response();
        } else {
            seller.response();
        }
    }

    public Order getOrder() {
        return order;
    }

    public void setOrder(Order order) {
        this.order = order;
    }

    public Seller getSeller() {
        return seller;
    }

    public void setSeller(Seller seller) {
        this.seller = seller;
    }
}