Java设计模式初探之二

此文章承接上文设计模式里的结构型，如有疑惑，请移步上一篇：https://www.jianshu.com/p/1a2bc93cd929

外观模式：

外观模式就是封装子系统的复杂组成，对外提供一个门面角色，客户端通过门面来操作系统，对内部子系统无知，子系统可以有多个，每个可以独立运行，可以被外部直接调用，对于子系统而言，门面角色也相当于客户端

例如：

public class ActionFace implements IModule{

    private IModule action1 = new ModuleA();
    private IModule action2 = new ModuleB();
    private IModule action3 = new ModuleC();

    @Override
    public void action() {
        action1.action();
        action2.action();
        action3.action();
    }
}

这里定义action1,action2,action3模块，总共有3个模块，使用一个类ActionFace来提供action方法，这样外部可以通过调用该方法来同时调用这3个模块，当然了，这3个模块也可以被单独调用，ActionFace只是相当于一个封装

组合模式：

这个模式一般什么情况下面使用呢，就是整体和单体相似，就像树形结构，举个例子，好比文件夹系统，文件夹和文件相似，构成一个树形结构的文件系统，存在一个root节点，文件夹和文件属性相似，这就可以构成组合

举个例子：

定义一个抽象类：

public abstract class Component {
    protected String name;

    public void setName(String name) {
        this.name = name;
    }
}

这个类有2个类组合用于形成树形结构：

public class RootComponent extends Component {

    private List<Component> list = new ArrayList<>();

    public void add(Component left){
        list.add(left);
    }
}
public class LeftComponent extends Component {

    private String leftProperty;
}

下一步就是组合这2个类：

public static void main(String[] args){
    RootComponent root = new RootComponent();
    Component item = new LeftComponent("left");
    Component item2 = new LeftComponent("right");

    Component root3 = new RootComponent();

    root.add(item);
    root.add(item2);
    root.add(root3);
}

创建root根类，然后添加子元素或者子节点，这个例子就如文件系统，部分和整体类似，所以可以整合在一起

享元模式

这个模式比较简单，就是在一个集合中拿出对象，如果集合里面没有，那么新建这个对象并放入这个集合里面，然后再给外面使用

定义如下：

public class SharedPool<T> {
    private HashMap<T,Object> map = new HashMap<>();

    public Object getEntity(T key){
        if(map.containsKey(key)) {
            return map.get(key);
        }else{
            Object o = new Object();
            map.put(key,o);
            return o;
        }
    }
}

这是一个根据key来查找存贮的值，如果不存在，新建加入Map然后返回该对象，当然了，这个可以定义成单利来存贮，不过请注意及时释放，不然会有内存泄漏哦~~

桥接模式：

这个设计模式目前自己也没有看懂。。。

行为型

责任链模式：

该设计模式个人理解为数据结构里面的单链表，每个元素都可能对客户端进行处理，如果一旦被消费了，那么即刻返回，当然也可能存在没有可以处理的请求

举个栗子：

定义一个抽象类，单链表里面每个元素构成如下：

public abstract class IHandler {
    private IHandler handler;
    public final void setNextHandler(IHandler handler) {
        this.handler = handler;
    }

    public final IHandler getNextHandler() {
        return handler;
    }

    public final boolean handleRequest(String args) {
        if(TextUtils.isEmpty(args)) {
            return onRequestHandle(args);
        }else{
            if(null != getNextHandler()) {
                return getNextHandler().handleRequest(args);
            }
        }
        return false;
    }

    abstract boolean onRequestHandle(String args);
}

public class DutyHandler extends IHandler{

    @Override
    boolean onRequestHandle(String args) {
        //handle request return true

        //otherwise return false visit next handle
        return false;
    }
}

链表里面每个子元素都是DutyHandler，使用setNextHandle保存下一个元素，下面我们编写测试：

public static void main(String[] args){
    IHandler topHandler = new DutyHandler();
    IHandler nextHandler = new DutyHandler();
    topHandler.setNextHandler(nextHandler);

    IHandler  nextHandler2= new DutyHandler();
    nextHandler.setNextHandler(nextHandler2);

    topHandler.handleRequest("");
}

这个例子创建的链表是这样的 topHandler -- nextHandler --nextHandler2

发送请求就会依次由头到尾调用handleRequest处理，如果成功，那么处理结束，否则查找下一个handler进行处理这个请求，但不保证一定能有链表元素能够处理

命令模式：

命令模式就是对接口实现体的一个分包装，将接口使用不同类引用并在实现体里面调用引用方法，这样可以将客户端与实现体分离，起到解耦作用，举个例子，假设有一个音乐播放器，有播放，停止，快进，返回等等，我们定义一个实现体：

public class AudioPlayer {
    public void play(){
        //play
    }

    public void pause(){
        //pause
    }

    public void stop(){
        //stop
    }

    public void skip(){
        //skip
    }
}

然后定义我们的客户端：

private ActionCommand pause,play,stop,skip;

private void test(){
    AudioPlayer player = new AudioPlayer();
    pause = new AudioPause(player);
    play = new AudioPlay(player);
    stop = new AudioStop(player);
    skip = new AudioSkip(player);

    pause.execute();
    play.execute();
    stop.execute();
    skip.execute();
}

这时候我们发现直接引用了AudioPlayer这个类型，如果需要添加新的功能，那么要修改这2块代码，产生了较高的耦合，下面我们用命令模式，让AudioPlayer对客户端不可见

1. 定义接口：

public interface ActionCommand {
    void execute();
}

2. 添加实现类：

2.1 播放方法的实现类

public class AudioPlay implements ActionCommand{
    private AudioPlayer player;

    public AudioPlay(AudioPlayer player) {
        this.player = player;
    }

    @Override
    public void execute() {
        player.play();
    }
}

2.2 暂停方法的实现类

public class AudioPause implements ActionCommand{
    private AudioPlayer player;

    public AudioPause(AudioPlayer player) {
        this.player = player;
    }

    @Override
    public void execute() {
        player.pause();
    }
}

2.3 停止实现类

public class AudioStop implements ActionCommand{
    private AudioPlayer player;

    public AudioStop(AudioPlayer player) {
        this.player = player;
    }

    @Override
    public void execute() {
        player.stop();
    }
}

2.4 跳过实现类

public class AudioSkip implements ActionCommand{
    private AudioPlayer player;

    public AudioSkip(AudioPlayer player) {
        this.player = player;
    }

    @Override
    public void execute() {
        player.skip();
    }
}

3. 解耦

private ActionCommand pause,play,stop,skip;

private void test(){
    AudioPlayer player = new AudioPlayer();
    pause = new AudioPause(player);
    play = new AudioPlay(player);
    stop = new AudioStop(player);
    skip = new AudioSkip(player);

    pause.execute();
    play.execute();
    stop.execute();
    skip.execute();
}

使用这样可以看出，最终对AudioPlayer进行不同类型包装，包装之后每个类型都是执行execute让后对应执行AudioPlayer相同方法，这样修改AudioPlayer不会对client产生影响，但是缺点就是定义了过多的接口实现类和指令代码

解释器模式：

感觉没遇到过，不做讨论

迭代模式：

这种设计模式主要讲解关于如何进行数据的迭代查找，用于遍历数组中的元素，设计需要实现Iterable与Iterator接口，其实就是学习这2个接口怎么使用，举例如下：

public class CustomMap<E> implements Iterable<E>{

    private E[] array = null;
    private int index = 0;

    public CustomMap(E[] array) {
        this.array = array;
        index = 0;
    }

    @NonNull
    @Override
    public Iterator<E> iterator() {
        return new CustomIterator();
    }

    private class CustomIterator implements Iterator<E>{

        @Override
        public boolean hasNext() {
            return index < array.length;
        }

        @Override
        public E next() {
            try {
                return array[index];
            }finally {
                index ++;
            }
        }
    }
}

编写测试方法：

public static void main(String[] args){
    Integer[] result = new Integer[]{1,2,5,9,77,51};
    CustomMap<Integer> map = new CustomMap<>(result);
    for (Integer i : map) {
        System.out.println(String.valueOf(i));
    }
}

上面的例子就是对一个数组封装然后实现遍历接口，这样就可以用for来迭代遍历。

中介者模式

该设计模式使用情况比较少，一般用于一个类影响多个类的情况，这种情况下，可能随便一个类都会影响其他多个类，这时候采取一个中介来控制其他类型，用于在一个类改变之后通过中介引用其他类来控制其他类变化

举个例子：假如有一个College类，有5个实例分别是abcde，当a改变的时候bce改变，当b改变的时候ace改变，当d改变的时候e改变，其他不变，那么我们可以这样做：

public class College {
    int value;

    public void setValue(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

public abstract class IAnency {

    College collegea,collegeb,collegec,colleged,collegee;

    public IAnency(College collegea, College collegeb, College collegec, College colleged, College collegee) {
        this.collegea = collegea;
        this.collegeb = collegeb;
        this.collegec = collegec;
        this.colleged = colleged;
        this.collegee = collegee;
    }

    abstract void setAnency(College target,College... others);
}

定义抽象类，添加抽象方法setAnency，然后定义实现类，第一个参数是改变的成员，后面可变数组是真正需要因第一个参数改变而改变的成员变量

备忘录模式

备忘录模式就是对原对象存储当前节点的状态，用于在以后起到恢复，这个设计模式有点像创建型里面的原型模式，但是原型模式是拷贝对象，这里的设计模式是对某个对象创建状态存储类，然后在合适的时候取出该对象然后执行覆盖恢复
举例：
假设有一个SnapEntity类，里面有statue变量，在某个时刻需要对这个类备份，用于以后需要的时候恢复：

public interface ISnap {
    //empty interface
}
public class SnapEntity {
    private int statue;

    public ISnap createEntity(){
        return new SnapShot(this.statue);
    }

    public void restoreSnapEntity(ISnap snapShot){
        statue = ((SnapShot)snapShot).statue;
    }

    public void setStatue(int statue) {
        this.statue = statue;
    }

    public int getStatue() {
        return statue;
    }

    static class SnapShot implements ISnap{
        private int statue;

        public SnapShot(int statue) {
            this.statue = statue;
        }

        public int getStatue() {
            return statue;
        }
    }
}

这里定义一个空接口用于恢复的时候强转恢复里面的数据，这样的好处就是外部不能直接访问备份文件，之后在执行变量恢复方法的时候才能访问
下面我们创建一个类来保存备份数据：

public class CareTaker {
    private ISnap snapShot;

    public void setSnapShot(ISnap snapShot) {
        this.snapShot = snapShot;
    }

    public ISnap getSnapShot() {
        return snapShot;
    }
}

创建测试方法：

public static void main(String[] args){
    SnapEntity entity = new SnapEntity();
    entity.setStatue(3);
    CareTaker taker = new CareTaker();
    taker.setSnapShot(entity.createEntity());
    entity.setStatue(7);
    entity.restoreSnapEntity(taker.getSnapShot());
    System.out.print(String.valueOf(entity.getStatue()));
}

这是一个将之前保存的数据3保存然后再修改之后进行恢复的测试，这就是备忘录模式，当然了，实际情况下一个类型可能有很多变量，我们可以按需来设计或者进行备份，然后再设计一个享元模式的缓存池或者存储。

观察者模式：

这种设计模式都已经用惯了，不多介绍，嘿嘿~

状态模式：

这种设计模式就是对一个行为有不同的实现类来处理，通过不同case来产生接口实现类，每个实现类有特点的实现机制，这就好比switch case语句，这里举个例子：
定义一个接口：

public interface IStatueHandler {
    void handleStatue(int args);
}

接口有3个实现类，A,B,C，这3个实现类实现不同方法，然后编写测试方法：

public void handleStatue(int what){
    IStatueHandler handler = null;
    if(0 < what && what < 11) {
        handler = new StatueHandlerA();
    }else if(what < 51){
        handler = new StatueHandlerB();
    }else{
        handler = new StatueHandlerC();
    }
    handler.handleStatue(what);
}

这就是一个状态模式的简单例子，其实就是一个接口不同实现，然后case不同情况进行处理，和下面将要提到的策略模式一样。

策略模式：

该设计模式很像状态模式，同样定义公共接口，然后每个接口有不同的实现策略，并且有且只有一个策略(实现类)可以处理请求，这些策略(实现类)可以被及时替换，耦合性低，这里不再介绍。

模板方法模式：

这种设计模式就是定义抽象类，然后提供抽象方法，在实现具体方法里面提供核心抽象方法由子类实现，这里不再举例