行为型 #

/**
 * 抽象诊断方法，因为现在只知道挂号和看医生是固定模式，剩下的开处方和拿药都是不确定的
 */
abstract class AbstractDiagnosis {

    public abstract void fallIll();

    public void test() {
        this.fallIll();
        System.out.println("1 >> 先挂号");
        System.out.println("2 >> 等待叫号");
        //由于现在不知道该开什么处方，所以只能先定义一下行为，然后具体由子类实现
        //大致的流程先定义好就行
        this.prescribe();
        //开药同理
        this.medicine();
    }

    //开处方操作根据具体病症决定了
    public abstract void prescribe();

    //拿药也是根据具体的处方去拿
    public abstract void medicine();
}

/**
 * 感冒相关的具体实现子类
 */
class ColdDiagnosis extends AbstractDiagnosis {

    @Override
    public void fallIll() {
        System.out.println("0 >> 感冒了");
    }

    @Override
    public void prescribe() {
        System.out.println("3 >> 一眼丁真，鉴定为假，这不是感冒，纯粹是想摆烂");
    }

    @Override
    public void medicine() {
        System.out.println("4 >> 开点头孢回去吃吧");
    }
}

abstract class Handler {

    //这里我们就设计责任链以单链表形式存在，这里存放后继节点
    protected Handler successor;

    //拼接后续节点
    public Handler connect(Handler successor) {
        this.successor = successor;
        //这里返回后继节点，方便我们一会链式调用
        return successor;
    }

    public void handle() {
        //由不同的子类实现具体处理过程
        this.doHandle();
        Optional
                .ofNullable(successor)
                //责任链上如果还有后继节点，就继续向下传递
                .ifPresent(Handler::handle);
    }

    //结合上节课学习的模板方法，交给子类实现
    public abstract void doHandle();
}

class FirstHandler extends Handler {
    //用于一面的处理器
    @Override
    public void doHandle() {
        System.out.println("============= 白马程序员一面 ==========");
    }
}

class SecondHandler extends Handler {
    @Override
    public void doHandle() {
        System.out.println("============= 白马程序员二面 ==========");
    }
}

class ThirdHandler extends Handler{
    @Override
    public void doHandle() {
        System.out.println("============= 白马程序员三面 ==========");
    }
}

public static void main(String[] args) {
    Handler handler = new FirstHandler();  //一面首当其冲
    handler
            .connect(new SecondHandler())   //继续连接二面和三面
            .connect(new ThirdHandler());
    handler.handle();   //开始面试
} 

interface Receiver {
    //具体行为，这里就写一个算了
    void action();
}

//指令抽象，不同的电器有指令
abstract class Command {

    private final Receiver receiver;

    //指定此命令对应的电器（接受者）
    protected Command(Receiver receiver) {
        this.receiver = receiver;
    }

    //执行命令，实际上就是让接收者开始干活
    public void execute() {
        receiver.action();
    }
}

//遥控器只需要把我们的指令发出去就行了
class Controller {
    public static void call(Command command) {
        command.execute();
    }
}

class AirConditioner implements Receiver {
    @Override
    public void action() {
        System.out.println("空调已开启，呼呼呼");
    }
}

class OpenCommand extends Command {
    public OpenCommand(AirConditioner airConditioner) {
        super(airConditioner);
    }
}

class Mediator {   //房产中介
    //在出售的房子需要存储一下
    private final Map<String, String> userMap = new HashMap<>();

    //出售房屋的人，需要告诉中介他的房屋在哪里
    public void register(String address, String user){
        userMap.put(address, user);
    }

    //通过此方法来看看有没有对应的房源
    public String find(String address){
        return userMap.get(address);
    }
}

class User {   //用户可以是出售房屋的一方，也可以是寻找房屋的一方
    String name;
    String tel;

    public User(String name, String tel) {
        this.name = name;
        this.tel = tel;
    }
  
    public User find(String address, Mediator mediator){   //找房子的话，需要一个中介和你具体想找的地方
        return mediator.find(address);
    }

    @Override
    public String toString() {
        return name+" (电话："+tel+")";
    }
}

public class MediatorModeMain {

    public static void main(String[] args) {
        //出租人
        User user0 = new User("刘女士", "10086");
        //找房人
        User user1 = new User("李先生", "10010");
        Mediator mediator = new Mediator();   //我是黑心中介

        //先把房子给中介挂上去
        mediator.register("上海静安汶水路白马程序员", user0);

        //开始找房子
        user1.find("上海静安汶水路下硅谷", mediator);
        //开始找房子
        user1.find("上海静安汶水路白马程序员", mediator);
    }

}