策略模式、模板方法与观察者：理解十二种行为型设计模式-优快云博客

本文链接：https://blog.youkuaiyun.com/a_001aaa/article/details/120295121

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

策略模式 Strategy

策略类之间可以自由切换，由于策略类实现自同一个抽象，所以他们之间可以自由切换。易于扩展，增加一个新的策略对策略模式来说非常容易，基本上可以在不改变原有代码的基础上进行扩展。避免使用多重条件，如果不使用策略模式，对于所有的算法，必须使用条件语句进行连接，通过条件判断来决定使用哪一种算法，在上一篇文章中我们已经提到，使用多重条件判断是非常不容易维护的。

public interface Strategy {
    void doMethod();
}
//具体策略
public class ConcreteStrategy1 implements Strategy{
    @Override
    public void doMethod() {
        System.out.println("ConcreteStrategy1...run........");
    }
}
public class ConcreteStrategy2 implements Strategy{

    @Override
    public void doMethod() {
        System.out.println("ConcreteStrategy2...run.....");
    }
}
public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void execute(){
        strategy.doMethod();
    }
}
  public static void main(String[] args) {
        Context context;
        context = new Context(new ConcreteStrategy1());
        context.execute();
        context = new Context(new ConcreteStrategy2());
        context.execute();
    }

模板 TemplateMethod

abstract public class Templata {
    public abstract void job();
    public void calculateTime(){
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println("执行时间:"+ (end - start));
    }
}
public class AA extends Templata{

    @Override
    public void job() {
        long num = 1;
        for (int i = 1; i < 8000000; i++) {
            num *= i;
        }
    }
}
public class BB extends Templata{

    @Override
    public void job() {
        long num = 0;
        for (long i = 1; i < 8000000; i ++){
            num+= i;
        }
    }
}
 public static void main(String[] args) {
        AA aa= new AA();
        aa.calculateTime();

        BB bb = new BB();
        bb.calculateTime();
    }

观察者Observer

观察者事件源本身处理事件

大多数时候我们处理事件的时候需要具体的源对象

事件也可以形成继承体

 private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
    }

    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;
        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed", this);

        for(Observer o : observers) {
            o.actionOnWakeUp(event);
        }
    }
}

abstract class Event<T> {
    abstract T getSource();
}
// 事件类 fire Event
class wakeUpEvent extends Event<Child>{
    long timestamp;
    String loc;
    Child source;

    public wakeUpEvent(long timestamp, String loc, Child source) {
        this.timestamp = timestamp;
        this.loc = loc;
        this.source = source;
    }

    @Override
    Child getSource() {
        return source;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {
    public void feed() {
        System.out.println("dad data...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum qiata...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        hug();
    }
}
====================================
     public static void main(String[] args) {
        Child c = new Child();
        c.wakeUp();
    }

迭代器Iterator

一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。

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

interface Iterator_ {
    public Object next();
    public boolean hasNext();
}

class ConcreteIterator_ implements Iterator_ {
    private List list = new ArrayList();
    private int cursor = 0;

    public ConcreteIterator_(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;
    }
}

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

class ConcreteAggregate implements Aggregate {
    private List list = new ArrayList();

    public void add(Object obj) {
        list.add(obj);
    }

    public Iterator_ iterator() {
        return new ConcreteIterator_(list);
    }

    public void remove(Object obj) {
        list.remove(obj);
    }
}

责任链 ChainOfResponsibility

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将整个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

public static void main(String[] args) {
        //来一张请假条
        Leave leave = new XiaoMing("xiaoming",5,"事假");
        Handler groupLeader = new GroupLeader();
        Handler managerLeader = new Manager();
        Handler bigManager = new BigManager();
        groupLeader.setNextHandler(managerLeader);
        managerLeader.setNextHandler(bigManager);

        groupLeader.submit(leave);

    }
}

//请假条接口
interface Leave{
    String getName();
    int getDay();
    String getContent();
}
class XiaoMing implements Leave{

    private String name;
    private int day;
    private String content;

    public XiaoMing(String name,int day,String content){
        this.content = content;
        this.day = day;
        this.name = name;
    }

    @Override
    public String getContent() {
        return name;
    }

    @Override
    public int getDay() {
        return day;
    }

    @Override
    public String getName() {
        return content;
    }
}

abstract class Handler{
    //类变量
    protected static final int NUM_ONE = 1;
    protected static final int NUM_THREE = 3;
    protected static final int NUM_SEVEN = 7;

    //上级领导
    private Handler nextHandler;
    //设置该领导的请假天数范围

    private int numStart;
    private int numEnd;

    //上不封顶
    public Handler(int numStart){
        this.numStart = numStart;
    }
    public Handler(int numStart,int numEnd){
        this.numStart = numStart;
        this.numEnd = numEnd;
    }

    //设置上级领导
    public void setNextHandler(Handler nextHandler){
        this.nextHandler=nextHandler;
    }

    public final  void submit(Leave leave){

        if(this.numStart == 0){

            return;
        }
        //当前领导处理,处理不了交给上级领导处理
        if(leave.getDay() >= numStart){

            this.handleLeave(leave);

            if(leave.getDay() > numEnd && this.nextHandler != null){
                this.nextHandler.submit(leave);
            }
        }


    }
    public abstract void handleLeave(Leave leave);

}

//领导实现
class GroupLeader extends Handler{

    GroupLeader(){
        super(Handler.NUM_ONE,Handler.NUM_THREE);
    }
    @Override
    public void handleLeave(Leave leave){
        System.out.println(leave.getName() + "请假" + leave.getDay() + "天," + leave.getContent() + "。");
        System.out.println("小组长审批：同意。");
    }
}

class Manager extends Handler{

    Manager(){
        super(Handler.NUM_THREE,Handler.NUM_SEVEN);
    }
    @Override
    public void handleLeave(Leave leave){
        System.out.println(leave.getName() + "请假" + leave.getDay() + "天," + leave.getContent() + "。");
        System.out.println("部门经理审批：同意。");
    }
}

class BigManager extends Handler{

    BigManager(){
        super(Handler.NUM_SEVEN);
    }
    @Override
    public void handleLeave(Leave leave){
        System.out.println(leave.getName() + "请假" + leave.getDay() + "天," + leave.getContent() + "。");
        System.out.println("董事长审批：同意。");
    }

命令模式Command

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。

//命令抽象
public interface Command {
    public void excute(); //执行
    public void undo();
}
//具体命令对象
public class SpecificCommands implements Command {

    Cometrue c;

    public SpecificCommands(Cometrue c) {
        this.c = c;
    }

    String s = " onetwo........wu...";
    @Override
    public void excute() {
        c.msg = c.msg + s;
        System.out.println(c.msg);
    }

    @Override
    public void undo() {
        c.msg = c.msg.substring(0, c.msg.length() - s.length());
        System.out.println(c.msg);
    }
}

//具体实现者
public class Cometrue {
    String msg ="hello..!";
}
public static void main(String[] args) {
        Cometrue c = new Cometrue();
        Command command = new SpecificCommands(c);
        command.excute();
        command.undo();
    }

备忘录 Memento

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样就可以将该对象恢复到原先保存的状态

public static void main(String[] args) {
        Originator originator = new Originator();
        originator.setState("状态1");
        System.out.println("初始状态:" + originator.getState());
        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(originator.createMemento());
        originator.setState("状态2");
        System.out.println("改变后状态:" + originator.getState());
        originator.restoreMemento(caretaker.getMemento());
        System.out.println("恢复后状态:" + originator.getState());
    }
}

class Originator {
    private String state = "";

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public Memento createMemento() {
        return new Memento(this.state);
    }

    public void restoreMemento(Memento memento) {
        this.setState(memento.getState());
    }
}

class Memento {
    private String state = "";

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

class Caretaker {
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

状态 State

当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类

// 工作中不同状态的例子
public class Work {
    // 时间点
    private int hour;
    
     //工作是否完成
    private boolean finish = false;

    public int getHour() {
        return hour;
    }

    public void setHour(int hour) {
        this.hour = hour;
    }

    public boolean isFinish() {
        return finish;
    }

    public void setFinish(boolean finish) {
        this.finish = finish;
    }

    public void writeProgram() {
        if (hour < 12) {
            System.out.println("当前时间" + hour + "上午工作，精神百倍");
        } else if (hour < 13) {
            System.out.println("当前时间" + hour + "饿了，午饭，犯困，休息");
        } else if (hour < 17) {
            System.out.println("当前时间" + hour + "下午状态还不错，继续努力");
        } else {
            if (finish) {
                System.out.println("当前时间" + hour + "下班回家了，开心");
            } else if (hour < 21) {
                System.out.println("当前时间" + hour + "加班哦，好难受");
            } else {
                System.out.println("当前时间" + hour + "不行了，睡着了");
            }
        }
    }
}

访问者Visitor

在结构不变的情况下动态改变对于内部元素的动作

public static void main(String[] args) {
            ObjectStructure objectStructure = new ObjectStructure();
            objectStructure.addElement(new ConcreateElementA());
            objectStructure.addElement(new ConcreateElementB());

            ConcreateVisitorA a = new ConcreateVisitorA();
            ConcreateVisitorB b = new ConcreateVisitorB();

            objectStructure.accept(a);
            objectStructure.accept(b);
        }
    }

/**
 * 访问者模式——抽象访问者角色
 */
 interface Visitor {
    // 为每一个具体元素对象都声明一个访问的操作方法
    void visitA(ConcreateElementA a);
    void visitB(ConcreateElementB b);
}

/**
 * 访问者模式——具体访问者角色A
 */
class ConcreateVisitorA implements Visitor {
    @Override
    public void visitA(ConcreateElementA a) {
        System.out.println("具体元素对象 A 被访问者 A 访问");
    }

    @Override
    public void visitB(ConcreateElementB b) {
        System.out.println("具体元素对象 B 被访问者 A 访问");
    }
}

/*
 *访问者模式——具体访问者角色B
 */
class ConcreateVisitorB implements Visitor {
    @Override
    public void visitA(ConcreateElementA a) {
        System.out.println("具体元素对象 A 被访问者 B 访问");
    }

    @Override
    public void visitB(ConcreateElementB b) {
        System.out.println("具体元素对象 B 被访问者 B 访问");
    }
}

/**
 * 访问者模式——抽象元素角色
 */
interface Element {
    // 需要的就是定义一个接收访问的方法
    void accept(Visitor visitor);
}

/**
 * 访问者模式——具体元素对象A
 */
class ConcreateElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visitA(this);
    }
}

/**
 * 访问者模式——具体元素对象B
 */
class ConcreateElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visitB(this);
    }
}

//访问者模式——对象结构角色
class ObjectStructure {
    // 可以枚举它的元素
    private List<Element> elements = new ArrayList<Element>();

    public void addElement(Element element) {
        elements.add(element);
    }

    public void removeElement(Element element) {
        elements.remove(element);
    }

    //还可以提供一个高层的接口
    public void accept(Visitor visitor) {
        for (Element element : elements) {
            element.accept(visitor);
        }
    }
}

中介者 Mediator

定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

//抽象中介者类
public abstract class Mediator {
    //注册同事
    public abstract void Register(Colleague colleague);

    //发送消息
    public abstract void SendMessage(Colleague targ,String msg);
}
//具体中介者
public class ConcreteMediator extends Mediator{
    //存放注册的同事
    List<Colleague> colleagues = new ArrayList<Colleague>();
    @Override
    public void Register(Colleague colleague) {
        //设置 中介者
        colleague.setMediator(this);
        colleagues.add(colleague);
    }
    @Override
    public void SendMessage(Colleague targ, String msg) {
        for (Colleague cl:colleagues) {
            if (targ == cl)
                cl.Receive(msg);
        }
    }
}
==========================================
    //同事类
public abstract class Colleague {
    //公共访问者 引入 中介者
    protected Mediator mediator;
    //设置中介者
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    //发送消息  谁发
    public abstract void Send(Colleague targ,String msg);
    //接收消息
    public abstract void Receive(String msg);
}
//具体同事类
public class ConcreteColleague extends Colleague {

    @Override
    public void Send(Colleague targ, String msg) {
        mediator.SendMessage(targ, msg);
    }

    @Override
    public void Receive(String msg) {
        System.out.println("同事1收到消息" + msg);
    }
}
//具体同事类
public class ConcreteColleague2 extends Colleague {

    @Override
    public void Send(Colleague targ, String msg) {
        mediator.SendMessage(targ, msg);
    }

    @Override
    public void Receive(String msg) {
        System.out.println("同事2收到消息" + msg);
    }
}
public class Main {
    public static void main(String[] args) {
        //定义一个中介者
        ConcreteMediator mediator = new ConcreteMediator();
        //定义同事
        ConcreteColleague cc1 = new ConcreteColleague();
        ConcreteColleague2 cc2 = new ConcreteColleague2();
        //注册
        mediator.Register(cc1);
        mediator.Register(cc2);

        cc1.Send(cc2,"hello woshi CC1!");
        cc2.Send(cc1,"hello woshi CC2!");
    }
}