java设计模式（三）

原文参考：https://blog.csdn.net/doymm2008/article/details/13288067

行为型设计模式：

第一类：通过父类和子类实现，第二类：通过两个类进行实现，第三类：通过类的状态实现，第四类：通过中间类实现

策略模式：定义了一系列算法，并将算法进行封装，使他们可以相互替换，而且算法的变化不会改变客户端的调用，需要设计一个接口，为一系列的实现类提供统一方法，多个实现类实现该接口，设计一个抽象类（可有可无），提供辅助函数

实例：

public interface ICalculate {
    public int calulate(String exp);
}

public class AbstractClass {
    public int[] split(String exp,String opt) {
        String[] split = exp.split(opt);
        int[] arr = new int[2];
        for(int i = 0;i<split.length;i++) {
            arr[i] = Integer.parseInt(split[i]);
        }
        return arr;
    }
}

public class Plus extends AbstractClass implements ICalculate{

    @Override
    public int calulate(String exp) {
        int[] arr = split(exp, "\\+");
        return arr[0]+arr[1];
    }
}

public class Minus extends AbstractClass implements ICalculate{

    @Override
    public int calulate(String exp) {
        int[] arr = split(exp, "\\-");
        return arr[0]-arr[1];
    }
    public static void main(String[] args) {
        String exp = "3+7";
        ICalculate plus = new Plus();
        System.out.println(plus.calulate(exp));
    }
}

运行结果：10

策略模式多用于算法决策系统中，外部用户只需要决定使用哪种算法即可

模板方法模式：一个抽象类中，有一个主方法，增加1到n个方法，可以是抽象方法，也可以是实际方法，定义一个类，继承抽象类，覆写抽象方法，实现通过抽象类完成对子类的调用

实例：

abstract class AbstractClass {
    public int calculate(String exp) {
        System.out.println("抽象方法的主方法");
        return getValue();
    }
    
    abstract int getValue();
}
public class SubClass extends AbstractClass{
    @Override
    int getValue() {
        System.out.println("进入子类方法");
        return 1;
    }
    public static void main(String[] args) {
        AbstractClass class1 = new SubClass();
        System.out.println(class1.calculate("jkj"));
    }
}

运行结果：

抽象方法的主方法
进入子类方法
1
观察者模式：当一个对象发生变化的时候，其他依赖该对象的所有对象都将收到通知，并随之发生变化。对象之间是一种一对多的关系

实例：

public interface Subject {

    /* 增加观察者 */
    public void add(Observer observer);

    /* 删除观察者 */
    public void del(Observer observer);

    /* 通知所有的观察者 */
    public void notifyObservers();

    /* 自身的操作 */
    public void operation();
}

public class AbstractSubject implements Subject{
    private Vector<Observer> observers = new Vector<>();
    @Override
    public void add(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void del(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        Enumeration<Observer> elements = observers.elements();
        while(elements.hasMoreElements()) {
            elements.nextElement().update();
        }
    }

    @Override
    public void operation() {
    }

}

public class MySubject extends AbstractSubject{

    @Override
    public void operation() {
        System.out.println("update self");
        notifyObservers();
    }
    public static void main(String[] args) {
        Observer observer1 = new Observer1();
        Observer observer2 = new Observer2();
        Subject subject = new MySubject();
        subject.add(observer1);
        subject.add(observer2);
        subject.operation();
    }
}

public interface Observer {
    public void update();
}

public class Observer1 implements Observer {

    @Override
    public void update() {
        System.out.println("观察者1发生变化");
    }

}

public class Observer2 implements Observer {

    @Override
    public void update() {
        System.out.println("观察者2发生变化");
    }

}
运行结果：
update self
观察者1发生变化
观察者2发生变化

迭代器模式：就是顺序访问聚集中的对象
实例：
public interface Collection {
    public Iterator getIterator();
    public Object get(int index);
    public int size();
}
 

public class MyCollection implements Collection{
    private String[] strings = {"A","B","C"};
    @Override
    public Iterator getIterator() {
        return new MyIterator(this);
    }

    @Override
    public Object get(int index) {
        return strings[index];
    }

    @Override
    public int size() {
        return strings.length;
    }

}
public interface Iterator {
    public Object previous();
    public Object next();
    public Object first();
    public boolean hasNext();
    public Collection getCollection();
}
 

public class MyIterator implements Iterator{
    private Collection collection;
    private int positon = -1;
    public MyIterator(Collection collection) {
        this.collection = collection;
    }
    @Override
    public Object previous() {
        if(positon>1) {
            positon--;
            return collection.get(positon);
        }
        return null;
    }

    @Override
    public Object next() {
        if(positon<collection.size()-1) {
            positon++;
            return collection.get(positon);
        }
        return null;
    }

    @Override
    public Object first() {
        return collection.get(0);
    }

    @Override
    public boolean hasNext() {
        if(positon<collection.size()-1) {
            return true;
        }
        return false;
    }
    
    public static void main(String[] args) {
        Collection collection = new MyCollection();
        Iterator iterator = collection.getIterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
    @Override
    public Collection getCollection() {
        return collection;
    }

}

责任链模式：即多个对象，每个对象都有下一个对象的依赖，这样就形成了一条链，请求在这条链上传递，直到某一个对象处理该请求，但是请求的发出者不知道最终是哪个对象处理了该请求，所以责任链可以满足，在隐瞒客户端的情况下，对系统进行动态调整

实例：
public interface Handler {
    public void operator();
}
public class AbstractHandler {
    private Handler handler;
    public Handler getHandler() {
        return handler;
    }
    public void setHandler(Handler handler) {
        this.handler = handler;
    }
}
public class MyHandler extends AbstractHandler implements Handler {
    private String name;
    public MyHandler(String name) {
        this.name = name;
    }
    public void operator() {
        System.out.println(name+" hello world!");
        if(getHandler()!=null) {
            getHandler().operator();
        }
    }
    public static void main(String[] args) {
        MyHandler h1 = new MyHandler("h1");
        MyHandler h2 = new MyHandler("h2");
        MyHandler h3 = new MyHandler("h3");
        
        h1.setHandler(h2);
        h2.setHandler(h3);
        
        h1.operator();
    }
}
运行结果：
h1 hello world!
h2 hello world!
h3 hello world!
链接上的请求可以是一条链，一棵树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同一时刻，只允许将命令从一个对象传到另一个对象，而不能传到多个对象

命令模式：
用一个例子来说明命令模式，司令员让士兵去干一件事情，司令员的作用，发出口令，口令经过传递，传到士兵的耳朵里，士兵去执行，三者互不依赖，互相解耦，任何一方都不需要依赖别人，只需要做自己的是就行，司令员要的是结果，不关注士兵怎么做

实例：
public interface Command {
    public void exec();
}
public class MyCommand implements Command{
    private Receiver receiver;
    
    public MyCommand(Receiver receiver) {
        this.receiver = receiver;
    }
    public void exec() {
        receiver.action();
    }
}
public class Receiver {
    public void action() {
        System.out.println("接收到口令的人去执行");
    }
}
public class Invoker {
    private Command command;
    public Invoker(Command command) {
        this.command = command;
    }
    public void action() {
        command.exec();
    }
    public static void main(String[] args) {
        Command command = new MyCommand(new Receiver());
        Invoker invoker = new Invoker(command);
        invoker.action();
    }
}
运行结果：接收到口令的人去执行
命令模式的目的就是达到命令的发出者和执行者进行解耦，实现请求和执行分开，比如struts，就是将请求和呈现分开，其中就用到了命令模式的思想

备忘录模式：就是为了保存某一对象的某一状态，以便在适当的时候进行对象状态恢复，也可以叫做备份模式，通俗的讲，就是有一个原始类A，A中有各种原始属性，A可以决定备份哪个属性，而备份类B，用来存储A内部的一些状态，类C就是为了存储备忘录的，只能存储，不能修改
实例：
 

public class Original {
    private String value;

    public Original(String value) {
        this.value = value;
    }
    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
    
    public Memoire createMemoire() {
        return new Memoire(value);
    }
    
    public void restoreMemoire(Memoire memoire) {
        this.value = memoire.getValue();
    }
    
}
public class Memoire {
    private String value;
    public Memoire(String value) {
        this.value = value;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    
}
 

public class Storage {
    private Memoire memoire;

    public Storage(Memoire memoire) {
        super();
        this.memoire = memoire;
    }

    public Memoire getMemoire() {
        return memoire;
    }

    public void setMemoire(Memoire memoire) {
        this.memoire = memoire;
    }
    public static void main(String[] args) {
        Original original = new Original("original");
        Storage storage = new Storage(original.createMemoire());
        
        System.out.println("初始状态位为："+original.getValue());
        original.setValue("modify");
        System.out.println("修改后状态为："+original.getValue());
        
        original.restoreMemoire(storage.getMemoire());
        System.out.println("恢复后的状态为:"+original.getValue());
    }
}
运行结果：
初始状态位为：original
修改后状态为：modify
恢复后的状态为:original

状态模式：当对象的状态发生改变的时候，改变其行为，有两点：1.可以通过改变状态来获得不同的行为 2.好友可以同时看到你的变化，可以想象为QQ的三种状态，在线，隐身，忙碌
实例：
 

public class State {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
    
    public void method1() {
        System.out.println("execute the first method!");
    }
    public void method2() {
        System.out.println("execute the second method!");
    }
    
}
 

public class Context {
    private State state;
    
    public Context(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }
    
    public void method() {
        if(state.getValue().equals("state1")) {
            state.method1();
        }else if(state.getValue().equals("state2")){
            state.method2();
        }
    }
    public static void main(String[] args) {
        State state = new State();
        Context context = new Context(state);
        state.setValue("state1");
        context.method();
        
        state.setValue("state2");
        context.method();
    }
}
运行结果：
execute the first method!
execute the second method!
根据这个特性，状态模式用的还是很多的，做网站的时候，我们可以根据对象的某一属性，区别开他们的功能，比如简单的权限控制

访问者模式：把数据结构和作用于其上的一系列操作解耦，使得操作集合可以相对的自由演化，访问者模式适用于数据结构相对稳定，算法易变的系统中，该模式使得算法操作增加更简单，但是如果数据结构多变，则不适合使用该模式，该模式优点：增加操作容易，因为增加操作就相当于增加访问者，简单来说，该模式就是将对象的数据结构和行为进行分离的方法
实例：
public interface Vistor {
    public void visit(Subject subject);
}
 

public class MyVistor implements Vistor {

    @Override
    public void visit(Subject subject) {
        System.out.println("visit the subject "+subject.getSubject());
    }

}
public interface Subject {
    public void accept(Vistor vistor);
    public String getSubject();
}
 

public class MySubject implements Subject{

    @Override
    public void accept(Vistor vistor) {
        vistor.visit(this);
    }

    @Override
    public String getSubject() {
        return "love";
    }
    
    public static void main(String[] args) {
        Vistor vistor = new MyVistor();
        Subject subject = new MySubject();
        subject.accept(vistor);
    }
}
运行结果：visit the subject love
适用场景：为现有的类增加新的功能，不得不考虑几个事情：1、新功能会不会与现有功能出现兼容性问题 2、以后会不会再需要增加 3、如果类不允许修改代码怎么办 ，这时候就考虑适用访问者模式

中介者模式：用来降低类与类之间的耦合，如果类与类之间有依赖，那么则不利于功能的拓展，因为只要修改一个对象，那么其关联对象也要进行修改，如果使用中介者模式，只需关心和Mediator类的关系，具体类类之间的关系及调度交给Mediator就行，这有点像spring容器的作用。
实例：
public interface Mediator {
    public void createMediator();
    public void workAll();
}

public class MyMediator implements Mediator{
    private User user1;
    private User user2;
    @Override
    public void createMediator() {
        user1 = new User1(this);
        user2 = new User2(this);
    }

    @Override
    public void workAll() {
        user1.work();
        user2.work();
    }
    public static void main(String[] args) {
        Mediator mediator = new MyMediator();
        mediator.createMediator();
        mediator.workAll();
    }

}
 

public abstract class User {
    private Mediator mediator;

    public Mediator getMediator() {
        return mediator;
    }

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
    public User(Mediator mediator) {
        this.mediator = mediator;
    }
    public void work() {};
}
 

public class User1 extends User{

    public User1(Mediator mediator) {
        super(mediator);
    }
    @Override
    public void work() {
        System.out.println("user1 work");
    }
}

public class User2 extends User{

    public User2(Mediator mediator) {
        super(mediator);
    }
    @Override
    public void work() {
        System.out.println("user2 work");
    }
}

运行结果：
user1 work
user2 work

解释器模式：一般用于oop编程，适用面比较窄
实例：
public interface Expression {
    public int interpreter(Context context);
}
public class Puls implements Expression{
    @Override
    public int interpreter(Context context) {
        return context.getNum1()+context.getNum2();
    }
}
 

public class Minus implements Expression{

    @Override
    public int interpreter(Context context) {
        return context.getNum1()-context.getNum2();
    }
}
public class Context {
    private int num1;
    private int num2;
    public Context(int num1, int num2) {
        super();
        this.num1 = num1;
        this.num2 = num2;
    }
    public int getNum1() {
        return num1;
    }
    public void setNum1(int num1) {
        this.num1 = num1;
    }
    public int getNum2() {
        return num2;
    }
    public void setNum2(int num2) {
        this.num2 = num2;
    }
    public static void main(String[] args) {
        // 计算9+2-8的值  
        int result = new Minus().interpreter((new Context(new Puls()  
                .interpreter(new Context(9, 2)), 8)));  
        System.out.println(result);  
    }
}
运行结果：3