面向接口编程的设计模式

简单工厂模式

• 假设程序中有个Computer类需要组合一个输出设备，现在有两个选择：直接让Computer类组合一个Printer，或者让Computer类组合一个Output，那么到底采用哪种方式更好呢？
• 假设让Computer类组合一个Printer对象，如果有一天系统需要重构，需要使用BetterPrinter来代替Printer，这就需要打开
  Computer类源代码进行修改。如果系统中只有一个Computer类组合了Printer还好，但如果系统中有100个类组合了Printer，甚至
  1000个、10000个……将意味着需要打开100个、1000个、10000个类进行修改，工作量十分巨大。

为了避免上面的问题发生，工厂模式建议让Computer类组合一个Output类型的对象，将Computer类与Printer类完全分离。Computer对象实际组合的是Printer对象还是BetterPrinter对象，对Computer而言完全透明。当Printer对象切换到BetterPrinter时，系统完全不受影响。代码如下：

public class Computer {    private Output out;    public Computer(Output out) {        this.out = out;    }    // 定义一个模拟获取字符串输入的方法    public void keyIn(String msg) {        out.getData(msg);    }    // 定义一个模拟打印的方法    public void print() {        out.out();    }}

• 上面的Computer类已经完全与Printer分离，只是与Output接口耦合。Computer不再负责创建Output对象，系统提供一个Output工厂来负责生成Output对象。这个OutputFactory工厂类代码如下：

public class OutputFactory {    public Output getOutput() {        return new Printer();    }    public static void main(String[] args) {        OutputFactory of = new OutputFactory();        Computer c = new Computer(of.getOutput());        c.keyIn("轻量级Java EE企业应用实战");        c.keyIn("疯狂Java讲义");        c.print();    }}

• 在该OutputFactory类中包含了一个getOutput方法，该方法负责创建Output实例并返回，如果系统需要将Printer改为BetterPrinter实现类，只需要让BetterPrinter实现Output接口，并改变OutputFactory类中的getOutput方法即可。

下面是BetterPrinter实现类的代码，BetterPrinter只是对原有的Printer进行简单修改，以模拟系统重构后的改进。

public class BetterPrinter implements Output {    private String[] printData = new String[MAX_CACHE_LINE * 2];    // 用以记录当前需打印的作业数    private int dataNum = 0;    public void out() {        // 只要还有作业，继续打印        while (dataNum > 0) {            System.out.println("高速打印机正在打印：" + printData[0]);            // 把作业队列整体前移一位，并将剩下的作业数减1            System.arraycopy(printData, 1, printData, 0, --dataNum);        }    }    public void getData(String msg) {        if (dataNum >= MAX_CACHE_LINE * 2) {            System.out.println("输出队列已满，添加失败");        } else {            // 把打印数据添加到队列里，已保存数据的数量加1。            printData[dataNum++] = msg;        }    }}

• 上面的BetterPrinter类也实现了Output接口，因此也可当成Output对象使用，于是只要把OutputFactory工厂类的getOutput方法修改即可。
• 再次运行前面的OutputFactory程序，发现系统运行时已经改为BetterPrinter对象，而不再是原来的Printer对象。通过这种方式，即可把所有生成Output对象的逻辑集中在Output工厂类中管理，而所有需要使用Output对象的类只需与Output接口耦合，而不是与具体的实现类耦合。即是系统中有很多类使用了Printer对象，只要OutputFactory类的getOutput方法生的是BetterPrinter对象，则他们全部都会改为使用BetterPrinter对象，而所有程序无需修改每只需要修改OutputFactory工厂类的getOutput方法实现即可。

命令模式

某个方法需要完成某一个行为，但这个行为的具体实现无法确定，必须等到执行该方法时才可以确定。具体一点：假设有个方法需要遍历某个数组的数组元素，但无法确定在遍历时如何处理这些元素，需要在调用该方法时指定具体的处理行为。
这个要求看起来有点奇怪：这个方法不仅需要普通数据可以变化，甚至还有方法执行提也需要变化，难道需要把“处理行为”作为参数传入该方法？
对于这样一个需求，可以考虑使用一个Command接口来定义一个方法，用这个方法来封装“处理行为”。下面是Command接口的代码：

public interface Command {    // 接口里定义的process方法用于封装“处理行为”    void process(int[] target);}

上面的process方法没有方法体，因为还无法确定这个处理行为。
下面是需要处理数组的处理类，在这个处理类中包含一个process方法，这个方法无法确定处理数组的处理行为，所以使用了一个Command参数，这个参数负责对数组的处理行为。

public class ProcessArray {    public void process(int[] target, Command cmd) {        cmd.process(target);    }}

通过一个Command接口，就实现了让ProcessArray和具体处理行为的分离，程序使用Command接口代表类对数组的处理行为。Command接口也没有提供真正的处理，只有等待需要调用ProcessArray对象的process方法是，才真正传入一个Command对象，才确定对数组的处理行为。
下面程序实现了对数组的两种处理方式：

public class CommandTest {    public static void main(String[] args) {        ProcessArray pa = new ProcessArray();        int[] target = { 3, -4, 6, 4 };        // 第一次处理数组，具体处理行为取决于PrintCommand        pa.process(target, new PrintCommand());        System.out.println("------------------");        // 第二次处理数组，具体处理行为取决于AddCommand        pa.process(target, new AddCommand());    }}public class PrintCommand implements Command {    public void process(int[] target) {        for (int tmp : target) {            System.out.println("迭代输出目标数组的元素:" + tmp);        }    }}public class AddCommand implements Command {    public void process(int[] target) {        int sum = 0;        for (int tmp : target) {            sum += tmp;        }        System.out.println("数组元素的总和是:" + sum);    }}