码迷,mamicode.com
首页 > 编程语言 > 详细

Java中的面向接口编程

时间:2016-05-30 14:15:57      阅读:197      评论:0      收藏:0      [点我收藏+]

标签:

 面向接口编程是很多软件架构设计理论都倡导的编程方式,学习Java自然少不了这一部分,下面是我在学习过程中整理出来的关于如何在Java中实现面向接口编程的知识。分享出来,有不对之处还请大家指正。

 

 

接口体现的是一种规范和实现分离的设计哲学,充分利用接口可以极好地降低程序各模块之间的耦合,从而提高系统的可扩展性和可维护性。基于这种原则,通常推荐“面向接口”编程,而不是面向实现类编程,希望通过面向接口编程来降低程序的耦合下面分两种常用场景来示范“面向接口”编程的优势。

(一)简单工厂模式

有一个场景,假设程序中有个Comupter类需要组合一个输出设备,现在有两个选择:直接让Comupter该类组合一个Printer属性,或者让Comupter组合一个Output属性,那么到底采用哪种方式更好呢?

假设让Computer组合一个Printer属性,如果有一天系统需要重构,需要使用BetterPrinter来代替Printer,于是我们需要打开Computer类源代码进行修改。如果系统中只有一个Computer类组合了Printer属性还好,如果系统中有100个类组合了Printer属性,甚至1000个,10000个……将意味着我们要打开100个、1000个、10000类进行修改,这是多么大的工作量!

为了避免这个问题,我们让Comupter组合一个Output属性,将Comupter类与Printer类完全分离。Computer对象实际组合的是Printer对象,还是BetterPrinter对象,对Computer而言完全透明。当Printer对象切换到BetterPrinter对象时,系统完全不受影响。下面是这个Computer类定义的代码。

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讲义");

c.keyIn("轻量级J2EE企业应用实战");

c.print();

}

}

在该OutputFactory类中包含了一个getOutput方法,该方法返回一个Output实现类的实例,该方法负责创建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方法中粗体部分改为如下代码:

return new BetterPrinter();

再次运行前面的OutputFactory.java程序,发现系统运行时已经改为BetterPrinter对象,而不再是原来的Printer对象。

通过这种方式,我们把所有生成Output对象的逻辑集中在OutputFactory工厂类中管理,而所有需要使用Output对象的类只需与Output接口耦合,而不是与具体的实现类耦合。即使系统中有很多类使用了Printer对象,只要OutputFactory类的getOutput方法来生成Output对象是BetterPrinter对象,则它们全部都会改为使用BetterPrinter对象,而所有程序无需修改,只需要修改OutputFactory工厂的getOutput的方法实现即可。


(二)命令模式

考虑这样一种场景:某个方法需要完成某一个行为,但这个行为的具体实现无法确定,必须等到执行该方法时才可以确定。具体一点:假设有个方法需要遍历某个数组的数组元素,但无法确定在遍历数组元素时如何处理这些元素,需要在调用该方法时指定具体的处理行为。

这个要求看起来有点奇怪:这个方法需要不仅要普通数据可以变化,甚至还有方法执行体也需要变化,难道我们能把“处理行为”作为一个参数传入该方法?

对于这样一个需求,我们必须把“处理行为”作为参数传入该方法,这个“处理行为”用编程来实现就是一段代码。那如何把这段代码传入该方法呢?

因为Java不允许代码块单独存在,因此我们使用一个Command接口来定义一个方法,用这个方法来封装“处理行为”。下面是该Command接口代码。

public interface Command

{

//接口里定义的process方法用于封装“处理行为”

void process(int[] target);

}

上面的Command接口里定义了一个process方法,这个方法用于封装“处理行为”,但这个方法没有方法体——因为现在还无法确定这个处理行为。

下面是需要处理数组的处理类,在这个处理类中包含一个process方法,这个方法无法确定处理数组的处理行为,所以定义该方法时使用了一个Command参数,这个Command参数负责对数组的处理行为。该类的程序代码如下。

public class ProcessArray

{

public void process(int[] target , Command cmd) 

{

cmd.process(target);

}

}

通过一个Command类,就实现了让ProcessArray类和具体“处理行为”的分离,程序使用Command接口代表了对数组的处理行为。Command接口也没有提供真正的处理,只有等到需要调用ProcessArray对象process方法时,才真正传入一个Command对象,才确定对数组的处理行为。

下面程序示范了对数组的两种处理方式:

public class TestCommand

{

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());

}

}

下面分别是PrintCommand类和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);

}

}

对于PrintCommand和AddCommand两个实现类而言,实际有意义的部分就是process(int[] target)方法,该方法的方法体就是传入ProcessArray类里process方法的“处理行为”,通过这种方式就可实现process方法和“处理行为”的分离。

Java中的面向接口编程

标签:

原文地址:http://www.cnblogs.com/android-blogs/p/5542153.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!