行为型设计模式（责任链、命令、迭代器、中介者、备忘录、观察者、状态、策略、模板、访问者）

责任链模式

把请求挨个传给不同的处理者。

// 请求类
public class Request {
    private int type = 0; // 请求类型
    private float price = 0.0f; // 请求金额
    private int id = 0;
    // 构造器
    public Request(int type, float price, int id) {
        this.type = type;
        this.price = price;
        this.id = id;
    }
    public int getType() {
        return type;
    }
    public float getPrice() {
        return price;
    }
    public int getId() {
        return id;
    }
}

//处理人 接口
public abstract class Approver {
    Approver approver;  // 下一个处理者
    String name; // 名字
    public Approver(String name) {
        this.name = name;
    }
    // 下一个处理者
    public void setApprover(Approver approver) {
        this.approver = approver;
    }
    // 处理审批请求的方法,得到一个请求,处理是子类完成,因此该方法做成抽象。
    public abstract void processRequest(Request request);
}

//处理人 实现类
public class SmallApprover extends Approver{
    public SmallApprover(String name) {
        super(name);
    }
    @Override
    public void processRequest(Request request) {
        if(request.getPrice() < 10000) {
            System.out.println(" 请求编号 id= " + request.getId() + " 被 " + this.name + " 处理");
        }else {
            //自己不能处理时,让下一位干.
            approver.processRequest(request);
        }
    }
}

//处理人 实现类
public class BigApprover extends Approver {
    public BigApprover(String name) {
        super(name);
    }
    @Override
    public void processRequest(Request request) {
        if(10000 <= request.getPrice()) {
            System.out.println(" 请求编号 id= " + request.getId() + " 被 " + this.name + " 处理");
        }else {
            //自己不能处理时,让下一位干.
            approver.processRequest(request);
        }
    }
}

    public static void main(String[] args) {
        //创建一个请求
        Request request = new Request(1, 10000, 1);
        //创建相关的审批人
        SmallApprover small = new SmallApprover("小工头");
        BigApprover big = new BigApprover("大工头");
        // 需要将各个处理人的下一个设置好 (处理人构成环形)
        small.setApprover(big);
        big.setApprover(small);
        //开始处理请求
        small.processRequest(request);
    }
结果:
 请求编号 id= 1 被 大工头 处理

命令模式

将一系列请求命令封装起来，不直接调用真正执行者的方法，好扩展。

//接收者：真正执行命令的对象
public class Receiver {
    public void action(){
        System.out.println("命令执行了.......");
    }
}

//抽象命令类：抽象的命令，可以根据不同类型的命令写出不同的实现
public interface Command {
    //调用命令
    void execute();
}

//具体命令类
class ConcreteCommand implements Command{
    private Receiver receiver;//持有真正执行命令对象的引用
    public ConcreteCommand(Receiver receiver) {
        super();
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        //调用接收者执行命令的方法
        receiver.action();
    }
}

//请求者/调用者：发起执行命令请求的对象
public class Invoker {
    private Command command;//持有命令对象的引用
    public Invoker(Command command) {
        super();
        this.command = command;
    }
    public void call(){
        //请求者调用命令对象执行命令的那个execute方法
        command.execute();
    }
}

    public static void main(String[] args) {
        //通过请求者（invoker）调用命令对象（command），命令对象中调用了命令具体执行者（Receiver）
        Command command = new ConcreteCommand(new Receiver());
        Invoker invoker = new Invoker(command);
        invoker.call();
    }

结果:
命令执行了.......

迭代器模式

通过引入迭代器,访问聚合类(存储多个对象)中的对象(元素)不暴露它的内部结构。无须了解聚合对象的内部结构即可实现对聚合对象中成员的遍历,可根据需要增加新的遍历方式。

public interface Aggregate {
    public void add(Object obj);
    public void remove(Object obj);
    public Iterator iterator();
}

public class MyAggregate implements Aggregate {
    private List list = new ArrayList();
    public void add(Object obj) {
        list.add(obj);
    }
    public Iterator iterator() {
        return new MyIterator(list);
    }
    public void remove(Object obj) {
        list.remove(obj);
    }
}

public class MyIterator implements Iterator {
    private List list = new ArrayList<>();
    private int cursor =0;
    public MyIterator(List list){
        this.list = list;
    }
    public boolean hasNext() {
        if(cursor==list.size()){
            return false;
        }
        return true;
    }
    public Object next() {
        Object obj = null;
        if(this.hasNext()){
            obj = this.list.get(cursor++);
        }
        return obj;
    }
}

public static void main(String[] args){
        Aggregate ag = new MyAggregate();
        ag.add("小明");
        ag.add("小红");
        ag.add("小刚");
        Iterator it = ag.iterator();
        while(it.hasNext()){
            String str = (String)it.next();
            System.out.println(str);
        }
    }
结果:
小明
小红
小刚

中介者模式

对象间不必相互明显引用,改变沟通和控制方式,低耦合。

//抽象中介者
public abstract class Mediator {
    //抽象的发送消息方法
    public abstract void send(String message, Colleague colleague);
}

//具体中介者类
public class ConcreteMediator extends Mediator {
    private AAColleague colleagueA;
    private BBColleague colleagueB;

    public void setColleagueA(AAColleague colleagueA) {
        this.colleagueA = colleagueA;
    }

    public void setColleagueB(BBColleague colleagueB) {
        this.colleagueB = colleagueB;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if(colleague == colleagueA) {
            colleagueB.notify(message);
        } else {
            colleagueA.notify(message);
        }
    }
}

//抽象同事类
public class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
}

public class AAColleague extends Colleague {
    public AAColleague(Mediator mediator) {
        super(mediator);
    }
    public void send(String message) {
        mediator.send(message, this);
    }
    public void notify(String message) {
        System.out.println("同事AA得到消息：" + message);
    }
}

public class BBColleague extends Colleague {
    public BBColleague(Mediator mediator) {
        super(mediator);
    }
    public void send(String message) {
        mediator.send(message, this);
    }
    public void notify(String message) {
        System.out.println("同事BB得到消息：" + message);
    }
}

 public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        AAColleague colleagueA = new AAColleague(mediator);
        BBColleague colleagueB = new BBColleague(mediator);

        mediator.setColleagueA(colleagueA);
        mediator.setColleagueB(colleagueB);

        colleagueA.send("****************");
        colleagueB.send("++++++++++++++++");
    }
结果:
同事BB得到消息：****************
同事AA得到消息：++++++++++++++++

备忘录模式

通过创建相同的对象来备份目标对象,副本吧。

//用于备份的对象
public class Memento {
    private String message;
    public Memento(String message) {
        super();
        this.message = message;
    }
    public String getVit() {
        return message;
    }
}

public class Role {
    private String message;
    public Role(String message) {
        this.message = message;
    }
    //创建 Memento,备份一下。
    public Memento createMemento() {
        return new Memento(message);
    }
    //从备忘录中恢复GameRole的状态。
    public void recover(Memento memento) {
        this.message = memento.getVit();
    }
    //显示当前角色的状态
    public void display() {
        System.out.println("此时的message: " + this.message);
    }
    public void setMessage(String message) {
        this.message = message;
    }
}

//守护者对象, 保存角色的状态
public class Caretaker {
    //如果只保存一次状态
    private Memento memento;
    //对GameRole 保存多次状态
    private ArrayList<Memento> mementos;
    //对多个游戏角色保存多个状态
    private HashMap<String, ArrayList<Memento>> rolesMementos;
    public Memento getMemento() {
        return memento;
    }
    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

    public static void main(String[]args){
        // 创建游戏角色
        Role role = new Role("AAAAAAA");
        role.display();
        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(role.createMemento());
        role.setMessage("BBBBB");
        role.display();
        role.recover(caretaker.getMemento());
        role.display();
    }
效果:
此时的message: AAAAAAA
此时的message: BBBBB
此时的message: AAAAAAA

观察者模式

// 被监视的接口
public interface Subject {
    public void addObs(Observer o);
    public void remvObs(Observer o);
    public void notifyObs();
}

//被监视的实现类
public class Weather implements Subject{
    private String message;
    //观察者集合
    private ArrayList<Observer> observers;
    //加入新的第三方
    public Weather(){
        observers = new ArrayList<Observer>();
    }
    //更新数据后 再调用 dataChange
    public void setData(String message) {
        this.message = message;
        //调用dataChange， 将最新的信息 推送给 接入方 currentConditions
        dataChange();
    }
    //通知观察者
    public void dataChange() {
        notifyObs();
    }
    //注册观察者
    @Override
    public void addObs(Observer o) {
        observers.add(o);
    }
    //移除观察者
    @Override
    public void remvObs(Observer o) {
        if(observers.contains(o)) {
            observers.remove(o);
        }
    }
    //遍历所有的观察者，并通知
    @Override
    public void notifyObs() {
        for(int i = 0; i <observers.size(); i++) {
            observers.get(i).update(this.message);
        }
    }
}

//观察者接口
public interface Observer {
    public void update(String message);
}

//观察者的实现
public class Jack implements Observer {
    private String message;
    // 更新 使用推送模式
    public void update(String message) {
        this.message = message;
        display();
    }
    // 显示
    public void display() {
        System.out.println("***Jack***");
        System.out.println("***现在的 message: " + message);
    }
}

//观察者的实现
public class Tom implements Observer {
    private String message;
    // 更新 由 Weather 来调用，使用推送模式
    public void update(String message) {
        this.message = message;
        display();
    }
    // 显示
    public void display() {
        System.out.println("=====Tom=====");
        System.out.println("***现在的 message: " + message);

    }
}

    public static void main(String[] args) {
        //创建一个 WeatherData
        Weather weather = new Weather();
        //创建两个观察者
        Jack jack = new Jack();
        Tom tom = new Tom();
        //把观察者注册到 weather
        weather.addObs(jack);
        weather.addObs(tom);
        //测试
        weather.setData("123456");
        System.out.println("******通知各个注册的观察者, 看看信息");

        //测试
        System.out.println();
        System.out.println("======通知各个注册的观察者, 看看信息");
        weather.setData("AAAAAAAAA");
    }
结果:
***Jack***
***现在的 message: 123456
=====Tom=====
***现在的 message: 123456
******通知各个注册的观察者, 看看信息

======通知各个注册的观察者, 看看信息
***Jack***
***现在的 message: AAAAAAAAA
=====Tom=====
***现在的 message: AAAAAAAAA

状态模式

一个对象可以有多个状态,如何切换对象的状态。

//状态接口
public interface State {
	void handle();
}

//状态实现类
public class WorkState implements State {
    @Override
    public void handle() {
        System.out.println("房间已预订！别人不能定！");
    }
}

//状态实现类
public class FreeState implements State {
	@Override
	public void handle() {
		System.out.println("房间空闲！！！没人住！");
	}
}
//环境类中维护一个State对象,定义了当前的状态.
public class HomeContext {
	private State state;
	public void setState(State s){
		System.out.println("修改状态！");
		state = s;
		state.handle();
	}
}

    public static void main(String[] args){
        // 获取房间对象
        HomeContext ctx = new HomeContext();
        // 设置房间状态
        ctx.setState(new FreeState());
        ctx.setState(new WorkState());
    }

结果:
修改状态！
房间空闲！！！没人住！
修改状态！
房间已预订！别人不能定！

策略模式

在运行时改变类行为或其算法(一个接口多个实现,用谁new谁)。

// 抽象策略类 
public interface CarFunction {
    void run();        
}

// 具体策略父类 
public class Car implements CarFunction {
    protected String name;
    protected String color;
    public Car(String name, String color) {
        this.name = name;
        this.color = color;
    }
    @Override
    public void run(){
        System.out.println(color +" " + name  +"在行驶。。。");
    }
}

// 具体策略实现子类
public class BMWCar extends Car {
    public BMWCar(String name, String color) {
        super(name, color);
    }
    public void run() {
        System.out.println(color +" " + name  +"宝马车在行驶......");
    }
}
// 具体策略实现子类
public class BenzCar extends Car{
    public BenzCar(String name, String color) {
        super(name, color);
    }
    public void run() {
        System.out.println(color +" " + name  +"奔驰车在行驶......");
    }
}
// 应用场景类
public class Person {
    private String name;    
    private Integer age;    
    private Car car;        
    public void driver(Car car){
        System.out.print(name +"  "+ age+" 岁 "+" 开着");
        car.run();
    }
    public Person(String name,Integer age) {
        this.name=name;
        this.age=age;
    }
}

public static void main(String[] args) {
	Car benz = new BenzCar("SUV ","黑色");
	Car bmw = new BMWCar("越野 ","白色");
	Person p1 = new Person("小明", 20);
	p1.driver(benz);
	p1.driver(bmw);
}

结果:
20 小明  20 岁  开着黑色 SUV 宝马车在行驶......
21 小明  20 岁  开着白色 越野 奔驰车在行驶......

模板模式

通过抽象类来定义逻辑模板、逻辑框架、逻辑原型,无法决定的部分写成抽象类,由子类来实现,类似 函数式接口。

//抽象类
public abstract class Cook {
    //模板方法,make,模板方法可以做成final,不让子类去覆盖.
    final void make() {
        prapare();
        if(customerWantCondiments()) {
            makeFood();
        }
        workOff();
    }
    void prapare() {
        System.out.println("准备好厨具、食材...  ");
    }
    //添加不同的配料, 抽象方法, 子类具体实现
    abstract void makeFood();
    //收工
    void workOff() {
        System.out.println("收拾好厨具、清理垃圾... ");
    }
    //钩子方法, 决定是否需要添加配料
    boolean customerWantCondiments() {
        return true;
    }
}
//子类
public class Potato extends Cook{
    @Override
    void makeFood() {
        System.out.println("******加入土豆,开始炒土豆... ");
    }
    @Override
    boolean customerWantCondiments() {
        return true;
    }
}
//子类
public class Fish extends Cook{
    @Override
    public void makeFood(){
        System.out.println("******加入鱼,开始烧鱼... ");
    }
    @Override
    boolean customerWantCondiments() {
        return true;
    }
}

    public static void main(String[] args) {
        System.out.println("----土豆丝----");
        Cook potato = new Potato();
        potato.make();
        System.out.println("");
        System.out.println("");
        System.out.println("----臭鳜鱼----");
        Cook fish = new Fish();
        fish.make();
    }

结果:
----土豆丝----
准备好厨具、食材...  
******加入土豆,开始炒土豆... 
收拾好厨具、清理垃圾... 

----臭鳜鱼----
准备好厨具、食材...  
******加入鱼,开始烧鱼... 
收拾好厨具、清理垃圾... 

访问者模式

行为型设计模式,将数据操作与数据结构分离。

// 员工基类(数据结构)
public abstract class Staff {
    public String name;
    public int kpi;// 员工KPI
    public Staff(String name) {
        this.name = name;
        kpi = new Random().nextInt(10);
    }
    // 核心方法，接受Visitor的访问
    public abstract void accept(Visitor visitor);
}
// 工程师
public class Engineer extends Staff {
    public Engineer(String name) {
        super(name);
    }
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    // 工程师一年的代码数量
    public int getCodeLines() {
        return new Random().nextInt(10 * 10000);
    }
}
// 经理
public class Manager extends Staff {
    public Manager(String name) {
        super(name);
    }
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    // 一年做的产品数量
    public int getProducts() {
        return new Random().nextInt(10);
    }
}
//访问者接口(数据操作)
public interface Visitor {
    // 访问工程师类型
    void visit(Engineer engineer);
    // 访问经理类型
    void visit(Manager manager);
}
// CTO访问者
public class CTOVisitor implements Visitor {
    @Override
    public void visit(Engineer engineer) {
        System.out.println("CTO 工程师: " + engineer.name + ", 代码行数: " + engineer.getCodeLines());
    }
    @Override
    public void visit(Manager manager) {
        System.out.println("CTO 经理: " + manager.name + ", 产品数量: " + manager.getProducts());
    }
}
// CEO访问者
public class CEOVisitor implements Visitor {
    @Override
    public void visit(Engineer engineer) {
        System.out.println("CEO 工程师: " + engineer.name + ", KPI: " + engineer.kpi);
    }
    @Override
    public void visit(Manager manager) {
        System.out.println("CEO 经理: " + manager.name + ", KPI: " + manager.kpi + ", 新产品数量: " + manager.getProducts());
    }
}

    public static void main(String[] args) {
        List<Staff> mStaffs = new LinkedList<>();
        mStaffs.add(new Manager("经理-A"));
        mStaffs.add(new Manager("经理-B"));
        mStaffs.add(new Engineer("工程师-A"));
        mStaffs.add(new Engineer("工程师-B"));
        mStaffs.add(new Engineer("工程师-C"));
        mStaffs.add(new Engineer("工程师-D"));
        Visitor ceoVisitor = new CEOVisitor();
        for (Staff staff : mStaffs) {
            staff.accept(ceoVisitor);
        }
        
        System.out.println("*************************");
        Visitor ctoVisitor = new CTOVisitor();
        for (Staff staff : mStaffs) {
            staff.accept(ctoVisitor);
        }
    }
结果:
CEO 经理: 经理-A, KPI: 0, 新产品数量: 9
CEO 经理: 经理-B, KPI: 5, 新产品数量: 7
CEO 工程师: 工程师-A, KPI: 8
CEO 工程师: 工程师-B, KPI: 1
CEO 工程师: 工程师-C, KPI: 5
CEO 工程师: 工程师-D, KPI: 5
*************************
CTO 经理: 经理-A, 产品数量: 6
CTO 经理: 经理-B, 产品数量: 4
CTO 工程师: 工程师-A, 代码行数: 33520
CTO 工程师: 工程师-B, 代码行数: 16006
CTO 工程师: 工程师-C, 代码行数: 9023
CTO 工程师: 工程师-D, 代码行数: 57101