Java_23种设计模式（四）----- 行为型模式

/* * 行为型模式： 4类11种 * 第一类： 父类与子类的关系  --- 继承关系 * 1. 策略模式 * 2. 模板方法模式 * 第二类： 两个类之间 --- 不存在继承关系 * 3. 观察者模式 * 4. 迭代子模式 * 5. 责任链模式 * 6. 命令模式 * 第三类： 类的状态 * 7. 备忘录模式 * 8. 状态模式 * 第四类： 通过中间类 * 9. 访问者模式 * 10. 中介者模式 * 11. 解释器模式 */public class ConstructModel {    // 1. 策略模式    ICalculator cal = new Plus();    cal.calculate("111");    // 2. 模板方法模式    AbstractCalculator1  c = new Plus1();    c.calculate("111");    // 3. 观察者模式    Subject s = new MySubject();    s.add(new Observer1());    s.add(new Observer2());    s.operation();    // 4. 迭代子模式    Collection c = new MyCollection();    Iterator it = c.iterator();    it.first();    // 5. 责任链模式    MyHander h1 = new MyHander("1");    MyHander h2 = new MyHander("2");    MyHander h3 = new MyHander("3");    h2.setHandler(h3);    h1.setHandler(h2);    h1.operation();    // 6. 命令模式    Invoker i = new Invoker(new MyCommand(new Receiver()));    i.action();    // 7. 备忘录模式    Original o = new Original("egg");    Storage s = new Storage(o.createMemento());    o.setValue("111");    o.restoreMemento(s.getMemento());    // 8. 状态模式    Context c = new Context(new State("fuck"));    c.method();    // 9. 访问者模式    Visitor visitor = new MyVisitor1();    Subject sub = new MySubject1();    sub.accept(visitor);    // 10. 中介者模式    Mediator m = new MyMediator();    m.createMediator();    m.workAll();    // 11. 解释器模式     // 9 + 2 -8    int result = new Minus1().interrupt(new Context1(        new Plus1().interrupt(new Context1(9,2)), 8));    System.out.println(result);}/* * 解释器模式(Interpreter) ---- 一般主要应用在OOP开发中的编译器开发，使用面窄 * 主要用来做各种各样的编译器， 如正则表达是的解释器等 */ class Minus implements Expression {    public int interpret(Context1 context) {        return context.getNum1() - context.getNum2();    }}class Plus1 implements Expression {    public int interpret(Context1 context ) {        return context.getNum1() + context.getNum2();    }}interface Expression {    int interpret(Context1 context);}// Context 类是一个上下文环境类， Plus和Minus分别是用来计算的实现class Context1 {    private int num1;    private int num2;    public Context(int num1, int num2) {this.num1 = num1; this.num2 = num2;}    public void setNum1(int num1) {this.num1 = num1;}    public void setNum2(int num2) {this.num2 = num2;}    public int getNum1() {return this.num1;}    public int getNum2 () {return this.num2;}}/* * 中介者模式(Mediator) ---- 用来降低类之间的耦合 类似于spring容器 * 如果类类之间有依赖关系的话， 不利于功能的扩展和维护。因为只要修改一个对象，其他关联的对象都得进行修改 * 最终对客户开放的类是MyMediator */class MyMediator implements Mediator {    private User user1;    private User user2;    public User getUser1() {return this.user1;}    public User getUser2 () {return this.user2;}    public void createMediator () {        user1 = new User1();        user2 = new User2();    }    public void work () {        user1.work();        user2.work();    }}class User2 extends User {    public void work () {System.out.println("User2 -> work");}}class User1 extends User {    public void work () {System.out.println("User1 -> work");}}abstract class User {    private Mediator mediator;    public Mediator getMediator() {return this.mediator;}    public User(Mediator m) {this.mediator = m;}    public abstract void work();}interface Mediator {    void createMediator();    void workAll();}/* * 访问者模式 ----- 把数据结构和作用于数据结构上的操作解耦，使得操作集合可相对自由地演化 * 该模式适用于数据结构相对稳定， 算法又易变化的系统 * 优点： 将有关行为集中到一个访问者对象中，其改变不影响系统结构 * 缺点： 增加新的数据结构很困难 * 目的： 一种分离对象数据结构与行为的方法，通过这种分离，可达到一个被访问者动态添加新的操作而无需做其他修改的效果 * visitor1 -> 相当于算法和行为 * mysubject1 -> 相当于数据结构 */class MySubject1 implements Subject1 {    public void accept (Visitor1 visitor) {visitor.visit(this);}    public String getSubject() {return "fuck";}}interface Subject1 {    void accept(Visitor1 visitor);    String getSubject();} class MyVisitor1 implements Visitor1 {    public void visit(Subject1 sub ) {System.out.println("MyVisitor1 -> visit"); sub.getSubject();}}interface Visitor1 {    void visit(Subject1 sub);}/* * 状态模式 ----- 当对象的状态改变时， 同时改变其行为 * 两点： 1、 通过改变状态来获得不同的行为 *        2、 其他对象能获取到变化 */class Context {    private State state;    public Context(State state ) {this.state = state;}    public void method () {        if ( "state1".equals(state.getValue())) {            state.method1();        } else {            state.method2();        }    }} class State {    private String value;    public State(String value) {this.value = value;}    public void setValue(String value ) {this.value = value;}    public String getValue () {return this.value;}    public void method1 () {System.out.println("State -> method1");}    public void method2 () {System.out.println("State -> method2");}}/* * 备忘录模式(Memento) ----- 目的： 保存一个对象的某个状态，以便在适当的时候恢复对相关 * 假设有原始类A， A中有各种属性，A可以决定要备份的属性，备忘录B是用来存储A的一些内部类 * 类C， 是一个用来存储备忘录B的，且只能存储，不能修改操作 */class Storage {    private Memento memento;    public Storage(Memento memento) {this.memento = memento;}    public Memento getMemento() {return this.memento;}    public void setMemento(Memento m ) {this.memento = m;}}class Memento {    private String value;    public Memento(String value) {this.value = value;}    public String getValue() {return this.value;}}class Original {    private String value;    public Original(String value) {this.value = value;}    public String getValue() {return this.value;}    public void setValue(String value) {this.value = value;}    public Memento createMemento() { return new Memento(value);}    public void resotreMemento(Memento m) {this.value = m.getValue();} }/* * 命令模式 ---- 目的： 达到命令发出者和执行者之间解耦，实现请求和执行分开，跟strut是相似 * 例子： 司令员下令让士兵去干件事 * 司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行 * 三者相互解耦 * 但是实际上，口令作为中间传输的连接，负责连接司令员和士兵，三者之间达到两两连接，实际操作者只有司令员和士兵，达到两者解耦效果 */class Invoker { // 司令员    private Command command;    public Invoker (Command command) {this.command = command;}    public void action() {command.exe();}}class Receiver { // 士兵    public void action() {System.out.println("Receiver -> action");}}class MyCommad implements Command {    private Receiver receiver;      public MyCommand(Receiver receiver) {this.receiver = receiver;}    public void exe() {receiver.action();}}interface Command {    void exe();}/* * 责任链模式------有多个对象，每个对象持有下一个对象的引用，会形成一条链，请求在这条链上传递，知道某一对象决定处理该请求 * 作用： 在隐瞒客户端的情况下，对系统进行动态的调整 * 注意： 链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要自己实现 *        同时在同一时刻，命令只允许由一个对象传给另一个对象，而不允许传给多个对象 */class MyHandler extends AbstractHandler {    private String name;    public MyHander(String name ) {this.name = name;}    public void Operation () {        if ( getHandler() != null ) {            getHandler().operation();        }    }}abstract class AbstractHandler implements Handler {    private Handler handler;    public Hander getHandler () {return this.handler;}    public void setHandler(Handler handler) {this.handler = handler;}}interface Handler {    void operation();} /* * 迭代子模式 --- 顺序访问聚集中的对象，一般来说，集合中非常常见 * 两层意思： 1. 需要遍历的对象，即聚集对象 *            2. 迭代器对象，用于对聚集对象进行遍历访问 */class MyIterator implements Iterator {    private Collection c;    private int pos = -1;    public MyIterator(Collection c ) {this.c = c;}    public Object previous() {        if ( pos > 0 ) {            pos--;        }        return c.get(pos);    }    public Object next () {        if ( pos < c.size() ) {            pos++;        }        return c.get(pos);    }    public boolean hasNext() {        if ( pos < c.size() - 1 ) {            return true;        }        return false;    }    public Object first() {        pos = 0;        return c.get(pos);    }}class MyCollection implements Collection {    public String str[] = {"A", "B", "C", "D"};    public Iterator iterator() {        return new Iterator(this);    }    public Object get(int i) {return str[i];}    public int size() {return str.lenth;}}interface Iterator {    Object previous();    Object next();    boolean hasNext();    Object first();}interface Collection {    Iterator iterator();    Object get(int i);    int size();}/* * 观察者模式 ---- 类似于邮件订阅 * 当一个对象变化时，其他依赖该对象的对象都会受到通知，并且随着变化。对象之间是一种一对多的关系 */class MySubject extends AbstractSubject {    public void option() {        notifyObserver();    }}abstract class AbstractSubject implements Subject {    Vector<Observer> vector = new Vector<Observer>();    public void add(Objserver o) {vector.add(o);}    public void del(Objserver o) {vector.remove(o);}    public void notifyObserver() {        Enumeration<Observer> enum = vector.elements();        while (enum.hasMoreElements()) {            enum.nextElement().update();        }    }}interface Subject{    void add(Observer o);    void del(Observer o);    void notifyObserver();    void option();}class Observer2 implements Observer {    public void update () {System.out.println("Observer2 -> update");}}class Observer1 implements Observer {    public void update() {System.out.println("Observer1 -> update");}} interface Observer {    void update();}/* * 模板方法模式 * 一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法 * 同时定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用 */class Minus2 extends AbstractCalculator1 {    public int calculate(String exp){return 0;}}class Plus3 extends AbstractCalculator1 {    public int calculate(String exp) {return 0;}}abstract class AbstractCalculator1 {    // 主方法    public int calculate(String exp, String opt) {return calculate(exp);}    // 抽象方法，被子类重写的方法    public abstract int calculate(String exp);}/* * 策略模式 -------定义一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户 * 就是一个父类，多个子类。父类引用指向子类对象 * 策略模式多用在算法决策系统中 */class Minus extends AbstractCalculate implements ICalculator {    public int calculate(String exp) {return 0;}}class Plus extends AbstractCalculate implements ICalculator {    public int calculate(String exp) {return 0;}} // 辅助类abstract class AbstractCalculate implements ICalculator {    public int[] split(String exp, String opt) {return null;}}interface ICalculator {    int calculate(String exp);}