让我们创建一个虚拟的例子。

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。