命令模式-适配器模式-外观模式-模板方法模式-迭代器模式-组合模式-状态模式-代理模式

命令模式：把一系列的操作封装成一个命令

代码：

import java.util.LinkedList;
import java.util.Queue;

public class Main {

    public static void main(String[] args) {
        Queue<command> cmdQueue = new LinkedList<command>();
        cmdQueue.offer(new GoToStore());
        cmdQueue.offer(new BuyFood());
        cmdQueue.offer(new EatFood());
        while (!cmdQueue.isEmpty()) {
            cmdQueue.poll().execute();
        }
    }
}


interface command {
    public void execute();
}


class GoToStore implements command {

    @Override
    public void execute() {
        System.out.println("Go to store");
    }

}


class BuyFood implements command {

    @Override
    public void execute() {
        System.out.println("Buy some food");
    }

}


class EatFood implements command {

    @Override
    public void execute() {
        System.out.println("Eat food");
    }

}

可以用于命令的队列，也可以用于日志请求（比如自动记录每一步的操作，方便撤销或者日后重复）。

设计思想：用一个接口封装算法实现，最后向上转型对各种不同的算法实现一视同仁（都调用execute方法）。

适配器模式：

不需要代码了，一句话就是两个接口不兼容，写一个适配器去兼容。比如一边给你个数组告诉你把他们打印出来，另外一边打印方法的参数是一个ArrayList，你就写个接口进行转换。这种思想到处其实都有用到，只是具体用到的时候情况可大可小。

外观模式：

定义一个接口为一系列复杂调用的外部接口，屏蔽其内部复杂的调用过程。很多地方也有用到，比如Executors工具类，就屏蔽了构造阻塞队列等等过程。（当然从设计模式上来说这个地方还用到了很多别的设计模式）

模板方法模式：

一个非常有用的模式，也是大量使用。

代码：

public class Main {

    public static void main(String[] args) {
        MakeTheDinner tom = new TomMakeDinner();
        tom.make();
        MakeTheDinner jack = new JackMakeDinner();
        jack.make();
    }
}


abstract class MakeTheDinner {

    public final void make() {
        buySomeMaterial();
        cleanTheTable();
        makeDishes();
    }

    private void buySomeMaterial() {
        System.out.println("Buy some material");
    }

    private void cleanTheTable() {
        System.out.println("Clean the table");
    }

    protected abstract void makeDishes(); // 具体的做菜
}


class TomMakeDinner extends MakeTheDinner {

    @Override
    protected void makeDishes() {
        System.out.println("Make seafood");
    }

}


class JackMakeDinner extends MakeTheDinner {

    @Override
    protected void makeDishes() {
        System.out.println("Make rice");
    }

}

思想：把一个算法的部分实现通过虚方法的方式交给子类，但是别的都放在一个final方法里面，可以做到该相同的代码都相同（final中的非虚代码），该不同的代码都不同（final中的虚方法）。

这个世界模式的意义在很久之后我才更加清楚。我目前能领悟的有两点，首先是封装可重用的代码。其次是组织代码结构，让父类做统一的流程控制，而让子类区分不同。然后是代码的复用性提升，几年前的代码依然可以简单使用。

迭代器模式：用迭代器屏蔽底层容器类的不同实现不同遍历方式，让外部可以通过相同的方式来遍历。

组合模式：当一个类里面有多重数据结构时（HashMap也能算），可以把各种迭代器组合起来使用。

状态模式：模拟有限状态机，写一个状态接口，所有具体实现（状态）都实现这个接口。同时让每一个状态都能够根据状态和操作确认下一步行动。

代理模式：如果真正的对象在网络的另外一端，可以写一个代理类让当前程序以为是在调用这个类，其实是这个类把相关信息发给网络上的另外一端。