让我们创建一个虚拟的例子。
A套餐类别
packageA：
package packageA;import packageB.B;public class A { private B myB; public A() { this.myB = new B(); } public void doSomethingThatUsesB() { System.out.println("Doing things with myB"); this.myB.doSomething(); }}B套餐类别
packageB：
package packageB;public class B { public void doSomething() { System.out.println("B did something."); }}如我们所见，
A取决于
B。没有
B，
A则不能使用。但是，如果
B将来我们想用
a代替
BetterB呢？对于这一点，我们创建了一个界面
Inter内
packageA：
package packageA;public interface Inter { public void doSomething();}为了利用这个界面，我们
import packageA.Inter;
让B implements Inter
中B
和- 替换出现的所有
B
内A
用Inter
。
结果是该版本的
A：
package packageA;public class A { private Inter myInter; public A() { this.myInter = ???; // What to do here? } public void doSomethingThatUsesInter() { System.out.println("Doing things with myInter"); this.myInter.doSomething(); }}我们已经看到，从
A到的依赖关系
B消失了：
import packageB.B;不再需要。仅存在一个问题：我们无法实例化接口的实例。但是控制权的转换很容易解决：与其
Inter在A构造函数中实例化某种类型的东西，构造器将需要一些
implements Inter作为参数的东西：
package packageA;public class A { private Inter myInter; public A(Inter myInter) { this.myInter = myInter; } public void doSomethingThatUsesInter() { System.out.println("Doing things with myInter"); this.myInter.doSomething(); }}通过这种方法，我们可以改变现在的具体实施Inter中A随意。假设我们编写了一个新类BetterB：
package packageB;import packageA.Inter;public class BetterB implements Inter { @Override public void doSomething() { System.out.println("BetterB did something."); }}现在我们可以实例化A具有不同的Inter实现：
Inter b = new B();A aWithB = new A(b);aWithB.doSomethingThatUsesInter();Inter betterB = new BetterB();A aWithBetterB = new A(betterB);aWithBetterB.doSomethingThatUsesInter();
而且我们不必更改其中的任何内容A。现在，代码已解耦Inter，只要满足合同，我们就可以随意更改的具体实现Inter。最值得一提的是，我们可以支持将在以后编写并实现的代码Inter。
