java - 在接口(interface)级别解耦两个类是什么意思？

Question

假设我们在包 A 中有类 A ，在包 B 中有类 B 。如果 A 类的对象引用了 B 类，则称这两个类之间存在耦合。

为了解决耦合问题，建议在包A中定义一个接口(interface)，由包B中的类实现，这样A类的对象就可以引用包A中的接口(interface)了。这通常是“依赖倒置”中的一个例子。

这就是“在接口(interface)级别解耦两个类”的例子吗？如果是，它如何去除类之间的耦合并在两个类耦合时保留相同的功能？

Answer 1

让我们创建一个 A 和 B 两个类的虚构示例。

包packageA中的类A:

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

packageB包中的B类:

package packageB;

public class B {
    public void doSomething() {
        System.out.println("B did something.");
    }
}

如我们所见，A 依赖于B。如果没有 B，则无法使用 A。我们说 A 与 B 紧密耦合。如果我们以后想用 BetterB 替换 B 怎么办？为此，我们在 packageA 中创建一个接口(interface) Inter:

package packageA;

public interface Inter {
    public void doSomething();
}

为了使用这个界面，我们

• import packageA.Inter;并让B在B中实现Inter，
• 用Inter替换A中所有出现的B。

结果是 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;。只有一个问题:我们不能实例化一个接口(interface)的实例。但是Inversion of control来救援:代替在 A 的构造函数中实例化 Inter 类型的东西，构造函数将要求 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();
    }
}

通过这种方法，我们现在可以随意更改 A 中 Inter 的具体实现。假设我们写了一个新类BetterB:

package packageB;

import packageA.Inter;

public class BetterB implements Inter {
    @Override
    public void doSomething() {
        System.out.println("BetterB did something.");
    }
}

现在我们可以用不同的Inter-实现来实例化A:

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。

---

附录

我在 2015 年写了这个答案。虽然对答案总体满意，但我一直认为缺少某些东西，我想我终于知道它是什么了。以下内容不是理解答案所必需的，但旨在激发读者的兴趣，并为进一步的自学提供一些资源。

在文献中，这种方法被称为 Interface segregation principle属于SOLID-principles .有一个nice talk from uncle Bob on YouTube (the interesting bit is about 15 minutes long)展示了如何使用多态性和接口(interface)来让编译时依赖点指向控制流(建议观众自行决定，Bob 叔叔会温和地提示 Java)。作为返回，这意味着高层实现在通过接口(interface)隔离时不需要了解低层实现。因此可以随意交换较低的级别，如上所示。