面向接口之简单工厂模式和命令模式

  接口体现的是一种规范和实现分离的设计哲学，充分利用接口可以极好的降低程序各模块间的耦合，从而提高系统的扩展性和可维护性。
  基于这一原则，很多软件架构设计理论都倡导“面向接口”编程,而不是面向实现类编程，希望通过面向接口编程来降低程序的耦合。

1、简单工厂模式

正常代码如下，Printer类实现了Output接口

//代码1
interface Output{
    static final int MAX_CACHE_LINE = 50;
    void out();
    void getData(String msg);
}
public class Printer implements Output{
    //存储打印对象的数组
    private String [] printData=new String [MAX_CACHE_LINE];
    //存储对象的数目
    private int dataNum=0;
    //
    @Override
    public void out() {
        while (dataNum>0){
            //打印第一个对象，之后数组整体前移一位
            System.out.println("Printer打印了——："+printData[0]);
            System.arraycopy(printData,1,printData,0,--dataNum);
        }

    }
    public void getData(String msg) {
        if(dataNum>MAX_CACHE_LINE){
            System.out.println("糟糕！！！打印序列已满，添加失败！");
        }
        else{
            printData[dataNum++]=msg;
        }
    }
    public static  void main(String args[]){
        Output o=new Printer();
        o.getData("Hello World!!!");
        o.getData("Hello Cruel World!!!");
        o.out();
    }
}

假如需要在一个Computer类中，组合Printer。如果选择让Computer类组合Printer则代码如下；

//代码2
package CodingFaceToInterface;

interface Output{
    static final int MAX_CACHE_LINE = 50;
    void out();
    void getData(String msg);

}
public class Printer implements Output{
    //存储打印对象的数组
    private String [] printData=new String [MAX_CACHE_LINE];
    //存储对象的数目
    private int dataNum=0;
    //
    @Override
    public void out() {
        while (dataNum>0){
            //打印第一个对象，之后数组整体前移一位
            System.out.println("Printer打印了——："+printData[0]);
            System.arraycopy(printData,1,printData,0,--dataNum);
        }

    }
    public void getData(String msg) {
        if(dataNum>MAX_CACHE_LINE){
            System.out.println("糟糕！！！打印序列已满，添加失败！");
        }
        else{
            printData[dataNum++]=msg;
        }
    }

}
class Computer{
    /*在Computer类中，组合了一个Printer对象
    如果后续的开发过程中，Printer类变化了，比如说增强了，变成了superPrinter
    那么，就得需要到Computer修改了，如果有成千上万个类，都组合了Printer，
    那么改起来会十分的麻烦。
     */
    Printer  p=new Printer();

    void pckeyIn(String msg){
        p.getData(msg);
    }
    void pcPrint(){
        p.out();
    }
    public static  void main(String args[]){

        Computer c=new Computer() ;
        c.pckeyIn("Hello");
        c.pckeyIn("Cruel");
        c.pckeyIn("World");
        c.pcPrint();
    }


}

3、如果在Computer类中，组合一个output对象，代码如下。

//代码三
package CodingFaceToInterface;

interface Output{
    static final int MAX_CACHE_LINE = 50;
    void out();
    void getData(String msg);

}
public class Printer implements Output{
    //存储打印对象的数组
    private String [] printData=new String [MAX_CACHE_LINE];
    //存储对象的数目
    private int dataNum=0;
    //
    @Override
    public void out() {
        while (dataNum>0){
            //打印第一个对象，之后数组整体前移一位
            System.out.println("Printer打印了——："+printData[0]);
            System.arraycopy(printData,1,printData,0,--dataNum);
        }

    }
    public void getData(String msg) {
        if(dataNum>MAX_CACHE_LINE){
            System.out.println("糟糕！！！打印序列已满，添加失败！");
        }
        else{
            printData[dataNum++]=msg;
        }
    }

}
class  outputFactory{

    public Output getOutputFactory(){

        return new Printer();
    }
        /*
    假如 claas  SuperPrinter implements Output{
    }
    我们想让Computer使用，SuperPrinter
    只需要  public Output getOutputFactory(){

        return new SuperPrinter();
    }

     */
    public static  void main(String args[]){
        outputFactory o=new outputFactory();
        Computer c=new Computer(o.getOutputFactory()) ;
        c.pckeyIn("Hello");
        c.pckeyIn("Cruel");
        c.pckeyIn("World");
        c.pcPrint();
    }

}

class Computer{
    //接口无法实例化，此处只是定义了一个变量，并没有实例化
   private Output  o;
  //构造器,传参为Output类型的变量
    Computer(Output o){
    this.o=o;
    }

    void pckeyIn(String msg){
        o.getData(msg);
    }
    void pcPrint(){
        o.out();
    }



}

2、命令模式

某个方法，要完成某一行为，但行为的具体实现无法确定，必须要等到执行到该方法时才能确定。

package CommandMode;

public interface Command{
    //接口李定义的process方法用于封装“处理行为”
    void process(int[]  target);
}
class PrintCommand implements Command{
    @Override
    public  void process(int[] target){
        for (int inTem:target) {
            System.out.println("输出目标数组的元素："+inTem);
        }
    }
        }
class  AddCommand implements Command{
    @Override
    public void process(int[] target) {
        int sum=0;
        for (int inTem:target){
            sum+=inTem;
        }
        System.out.println("对数组求和的结果是："+sum);
    }
}
class ProcessArry{

    public void process(int[] target,Command cmd){
        cmd.process(target);
    }
}
class  testCommand{
    public  static void main(String args[]){
        int[]  tar={0,1,2,3,4,5,6,7,8,9,10,};
        ProcessArry p=new ProcessArry();
        p.process(tar,new PrintCommand());
        p.process(tar,new AddCommand());

    }
}