如果现在有一个类Parent，里面有个属性的类型是Child，add的方法里面还有个参数的类型是Girl：
class Parent{
Child child;
void add(Girl girl){
...
}
} 因为上面Parent里面用到了Child跟Girl这两个类，我们就说，Parent引用了类Child跟类Girl。现在的问题是，如果Child这个类或者Girl这个类编译不过的话，那么Parent这个类也编译不了了。也就是说，Parent依赖于Child跟Girl。这章讲述的，就是因为一些类的依赖造成的无法重用的问题。
示例 这是一个处理ZIP的程序。用户可以在主窗口中先输入要生成的目标zip的路径，比如c:\f.zip ，然后输入他想压缩到这个zip的源文件的路径，比如
c:\f2.doc和c:\f2.doc 。然后这个程序就会开始压缩f1.doc和f2.doc，生成f.zip文件。在压缩各个源文件的时候，主窗口下的状态栏都要显示相关的信息。比如，在压缩c:\f2.doc的时候，状态栏就显示"正在压缩 c:\f2.zip"。
目前的代码就是
class ZipMainFrame extends Frame {
StatusBar sb;
void makeZip() {
String zipFilePath;
String srcFilePaths[];
//根据UI上给zipFilePath和srcFilePaths赋值
...
ZipEngine ze = new ZipEngine();
ze.makeZip(zipFilePath, srcFilePaths, this);
}
void setStatusBarText(String statusText) {
sb.setText(statusText);
}
}
class ZipEngine {
void makeZip(String zipFilePath, String srcFilePaths[], ZipMainFrame f) {
//在该路径上创建zip文件
...
for (int i = 0; i < srcFilePaths.length; i++) {
//将srcFilePaths[i]的文件加到压缩包中
...
f.setStatusBarText("Zipping "+srcFilePaths[i]);
}
}
} 我们还有一个存货管理系统，里面有一些程序的数据文件，经常需要压缩起来备份。这些源数据文件都有固定的路径，所以就不需要用户特地去输入路径了。现在我们想直接把上面的这个ZipEngine类拿过来重用。这个存货管理系统也有一个主窗口，同样在压缩待备份文件时，状态栏上面也要显示目前正在压缩的文件名称。
现在，问题来了。我们希望可以在不用修改代码的情况下直接重用ZipEngine这个类。但看了上面的代码以后我们发现：在调用makeZip这个方法时，还需要一个传递一个ZipMainFrame类型的参数进来。可是很明显我们现在的这个存货管理系统里面并没有ZipMainFrame这样的类。也就是说，现在ZipEngine这个类，在我们的这个存货管理系统中用不了了。
再往远一点想，好像其他的系统，一般也不会有ZipMainFrame这个类。即使类名一样的，里面所做的功能也不一样。那其他的系统也重用不了这个ZipEngine类了。
“不合适的依赖”，让代码很难被重用 因为ZipEngine引用了ZipMainFrame这个类，当我们想重用ZipEngine的时候，我们就需要将ZipMainFrame也加进来，调用ZipEngine的makeZip方法时，还要构造一个ZipMainFrame对象传给它。而在新的环境中，我们不可能有一个同样的ZipMainFrame，也不可能特地为了调用这个方法，随便创建一个ZipMainFrame对象给它。
一般来说，如果一个类A引用了一个类B，当我们想要重用A这个类时，我们就还得将B这个类也加进我们的系统。如果B引用了C，那么B又将C也一起拉了进来。而如果B或者C在一个新的系统中没有意义，或者压根儿不应该存在的情况下，真正我们想要用的A这个类也用不了了。
因此，“不合适的依赖”让代码很难被重用。
为了可以重用ZipEngine，首先，我们得让ZipEngine不再引用ZipMainFrame。或者说，让ZipEngine不用依赖于ZipMainFrame。
那怎么做呢？回答这个问题之前，我们先回答另一个问题：给你一段代码，你怎么判断这段代码是不是包含了“不合适的依赖”？“不合适”这个词定义的标准又是什么？
怎么判断是“不合适的依赖” 方法1：
一个简单的方法就是：我们先看一下这段代码里面有没有一些互相循环的引用。比如，ZipMainFrame引用了ZipEngine这个类，而ZipEngine又引用了ZipMainFrame。我们管这样的类叫“互相依赖”。互相依赖也是一种代码异味，我们就认定这样的代码，是“不合适的依赖”。
这个方法很简单。不过，这种方法并不能包含全部情况，并不是所有有“不合适的依赖”的代码，都是这种互相依赖。
方法2：
另一个方法比较主观：在检查代码的时候，我们问自己：对于它已经引用的这些类，是它真正需要引用的吗？对于ZipEngine，它真的需要ZipMainFrame这个类吗？ZipEngine只是改变ZipMainFrame的状态栏上的信息。是不是只有引用了ZipMainFrame才能满足这样的需求，其他类行不行？有没有一个类可以取代ZipMainFrame呢？而实际上，ZipEngine并不是一定要引用ZipMainFrame的。它想引用的，其实只是一个可以显示信息的状态栏而已。
因此，我们就将代码改为：
class ZipEngine {
void makeZip(String zipFilePath, String srcFilePaths[], StatusBar statusBar) {
//在该路径上创建zip文件
...
for (int i = 0; i < srcFilePaths.length; i++) {
//将srcFilePaths[i]的文件加到压缩包中
...
statusbar.setText("Zipping "+srcFilePaths[i]);
}
}
} 现在，ZipEngine只是引用了StatusBar，而不再是ZipMainFrame了。可是这样好吗？相对好一些！因为StatusBar比较通用（至少有StatusBar这个类的系统比ZipMainFrame多多了），这样的话，ZipEngine这个类的可重用性就大幅改观了。
不过，这样的方法还是太主观了。没有一个既定的标准，可以判断ZipEngine到底需要的是什么样的东西。比如，我们就说，ZipEngine其实想要的也不是一个状态栏，它只是想调用一个可以显示一些信息的接口而已(而不是一个状态栏这么大的一个对象)。
方法3：
第3种方法也很主观：在设计类的时候，我们先预测一个以后可能会重用这个类的系统。然后再判断，在那样的系统中，这个类能不能被重用？如果你自己都觉得以后的系统不能重用这个类的话，你就断定，这个类包含“不合适的依赖”了。
比如，我们在设计完ZipEngine这个类时，我们就想一下，这个类能在别的系统重用吗？可是好像别的系统，不会有ZipMainFrame这个类，至少一个没有GUI的系统会有这样的类！这样的话，那它就不应该引用ZipMainFrame这个类了。这个方法其实也很主观，不怎么实用。每个人预测的可能性都不一样。
方法4
第4个方法比较简单而且客观了。当我们想在一个新系统中重用这个类，却发现重用不了时，我们就判断，这个类包含了“不合适的依赖”。比如，我们在存货管理系统中，要重用ZipEngine的时候，我们才发现，这个类重用不了。这时我们就认定，这个类有“不合适的依赖”。
后一种方法是个“懒惰而被动的”方法，因为我们真正想在具体的项目中重用的时候，才能判断出来。不过这也是个很有效的方法。
总结 要判断一个代码是不是包含了“不合适的依赖”，共有四个方法：
1.看代码：有没有互相依赖？
2.认真想想：它真正需要的是什么？
3.推测一下：它在以后的系统中可以重用吗？
4.到要重用的时候就知道了：现在我要重用这个类，能不能重用？ 方法1跟4是最简单的方法，推荐初学者可以这样来判断。有更多的设计经验了，再用方法2跟3会好一些。
怎么让ZipEngine不再引用（依赖于）ZipMainFrame
现在我们来看看，怎么让ZipEngine不再引用ZipMainFrame。其实，在介绍方法2的时候，我们就已经通过思考发现，ZipEngine这个类真正需要的是什么，也找出了解决办法。不过因为方法2相对来讲并不是那么简单就可以用好的，所以我们先假装不知道方法2的结果。
我们用方法4。现在我们是在做一个文字模式的系统（没有状态栏了，我们只能直接在没有图形的屏幕上显示这些信息），发现ZipEngine不能重用了。怎么办？
因为我们不能重用ZipEngine，我们只好先将它的代码复制粘贴出来，然后再修改成下面的代码：
class TextModeApp {
void makeZip() {
String zipFilePath;
String srcFilePaths[];
...
ZipEngine ze = new ZipEngine();
ze.makeZip(zipFilePath, srcFilePaths);
}
}
class ZipEngine {
void makeZip(String zipFilePath, String srcFilePaths[]) {
//在该路径上创建zip文件
...
for (int i = 0; i < srcFilePaths.length; i++) {
//将srcFilePaths[i]的文件加到压缩包中
...
System.out.println("Zipping "+srcFilePaths[i]);
}
}
} 再看一下原来的代码是：
class ZipEngine {
void makeZip(String zipFilePath, String srcFilePaths[], ZipMainFrame f) {
//在该路径上创建zip文件
...
for (int i = 0; i < srcFilePaths.length; i++) {
//将srcFilePaths[i]的文件加到压缩包中
...
f.setStatusBarText("Zipping "+srcFilePaths[i]);
}
}
} 很明显，这里面有很多的重复代码（代码异味）。要消除这样的代码异味，我们就先用伪码让这两段代码看起来一样。比如，改成：
class ZipEngine {
void makeZip(String zipFilePath, String srcFilePaths[]) {
//在该路径上创建zip文件
...
for (int i = 0; i < srcFilePaths.length; i++) {
//将srcFilePaths[i]的文件加到压缩包中
...
显示信息。。。
}
}
} 因为“显示信息”具体出来，有两种实现，所以我们现在创建一个接口，里面有一个方法用来显示信息。这个方法可以直接取名为“showMessage”，而根据这个接口做的事，我们也可以直接将接口名取为“MessageDisplay”或者“MessageSink”之类的：
interface MessageDisplay {
void showMessage(String msg);
}
将ZipEngine改为：
class ZipEngine {
void makeZip(String zipFilePath, String srcFilePaths[], MessageDisplay
msgDisplay) {
//在该路径上创建zip文件
...
for (int i = 0; i < srcFilePaths.length; i++) {
//将srcFilePaths[i]的文件加到压缩包中
...
msgDisplay.showMessage("Zipping "+srcFilePaths[i]);
}
}
} 而MessageDisplay这个接口的两个实现类就是：
class ZipMainFrameMessageDisplay implements MessageDisplay {
ZipMainFrame f;
ZipMainFrameMessageDisplay(ZipMainFrame f) {
this.f = f;
}
void showMessage(String msg) {
f.setStatusBarText(msg);
}
}
class SystemOutMessageDisplay implements MessageDisplay {
void showMessage(String msg) {
System.out.println(msg);
}
} 现在两个系统也相应的做了修改：
class ZipMainFrame extends Frame {
StatusBar sb;
void makeZip() {
String zipFilePath;
String srcFilePaths[];
//根据UI上给zipFilePath和srcFilePaths赋值
...
ZipEngine ze = new ZipEngine();
ze.makeZip(zipFilePath, srcFilePaths, new ZipMainFrameMessageDisplay(this));
}
void setStatusBarText(String statusText) {
sb.setText(statusText);
}
}
class TextModeApp {
void makeZip() {
String zipFilePath;
String srcFilePaths[];
...
ZipEngine ze = new ZipEngine();
ze.makeZip(zipFilePath, srcFilePaths, new SystemOutMessageDisplay());
}
} 改进后的代码
下面就是改进完的代码。为了让代码看起来清楚一些，我们用了Java的内类：
interface MessageDisplay {
void showMessage(String msg);
}
class ZipEngine {
void makeZip(String zipFilePath, String srcFilePaths[], MessageDisplay
msgDisplay) {
//在该路径上创建zip文件
...
for (int i = 0; i < srcFilePaths.length; i++) {
//将srcFilePaths[i]的文件加到压缩包中
...
msgDisplay.showMessage("Zipping "+srcFilePaths[i]);
}
}
}
class ZipMainFrame extends Frame {
StatusBar sb;
void makeZip() {
String zipFilePath;
String srcFilePaths[];
//根据UI上给zipFilePath和srcFilePaths赋值
...
ZipEngine ze = new ZipEngine();
ze.makeZip(zipFilePath, srcFilePaths, new MessageDisplay() {
void showMessage(String msg) {
setStatusBarText(msg);
}
});
}
void setStatusBarText(String statusText) {
sb.setText(statusText);
}
}
class TextModeApp {
void makeZip() {
String zipFilePath;
String srcFilePaths[];
...
ZipEngine ze = new ZipEngine();
ze.makeZip(zipFilePath, srcFilePaths, new MessageDisplay() {
void showMessage(String msg) {
System.out.println(msg);
}
});
}
} 引述 依赖反转原则（Dependency Inversion Principle ）表述：抽象不应该依赖于具体，高层的比较抽象的类不应该依赖于低层的比较具体的类。当这种问题出现的时候，我们应该抽取出更抽象的一个概念，然后让这两个类依赖于这个抽取出来的概念。更多的信息，可以看：
http://www.objectmentor.com/resources/articles/dip.pdf
http://c2.com/cgi/wiki?DependencyInversionPrinciple
完整pdf下载地址：
敏捷开发的必要技巧
