java - oop:理解类之间的依赖和耦合

Question

这到底是什么意思，一个类对另一个类了解太多？

示例(改编自此处 https://courses.cs.washington.edu/courses/cse331/12au/lectures/08-events.pdf )

class AAA {

    public void method1() {
        //do something
        method2();
    }

    public void method2();
      // do something
    }
}

class BBB {

    private AAA ref = new AAA();

    public void start() {
        while(true) {
            if (something) {
                ref.method1();
            }
        }
    }

}

class Main {

    public static void main(String[] args) {
        BBB ref = new BBB();
        ref.start();
    }

}

文档中说

1. 主类依赖BBB
2. BBB 依赖于 AAA

提出的问题是

1. BBB 是否需要依赖 AAA？
2. BBB 是否可以在新环境中重复使用？

关于 2. - 是吗？如果不是，为什么不呢？为什么对 AAA 的依赖会阻止它在新的上下文中使用？这里的上下文是否意味着“与不同的类”？

它说虽然 BBB 需要调用方法 1()，但它不需要知道该方法的作用。因此，您应该通过使用 AAA 的接口(interface)/抽象类而不是 AAA 本身来削弱依赖性(松散耦合)

很新:

class AAA extends AbstractAAA {
// same 
}

class BBB {
    AbstractAAA ref;

    public BBB (AbstractAAA param) {
        this.ref = param;
    }

        public void start() {
        while(true) {
            if (something) {
                ref.method1();
            }
        }
    }
}

class Main {
        BBB ref = new BBB(new AAA());
        ref.start();
}

现在它说main仍然依赖于BBB并且它依赖于AAA的构造函数，但是BBB不受AAA的实现细节的影响。

因此，从广义上讲，依赖意味着“使用……的实例”，因此我看到 Main 依赖于 BBB 和 AAA，而 BBB 以前依赖于 AAA，现在依赖于抽象类，这是一个较弱的依赖。

我不明白的是，依赖项和实现细节究竟有什么问题，如果另一个类发生变化，则必须进行更改。我知道最好使用接口(interface)和抽象类作为方法和构造函数的参数，因为您可以传递任何扩展/实现类/接口(interface)的类。但是带有实现细节的东西。当我有一个类的引用(并创建一个依赖项)并调用一个公共(public)方法时，我如何依赖实现细节？仅仅因为我调用了那个方法并不意味着我知道里面发生了什么......？

我已经在 SO 上查看了其他示例，但我仍然不太明白......

Answer 1

Regarding 2. - Is it? And if not, why is it not? Why could the dependency on AAA prevent it from being used in a new context? Does context here mean "with a different class"?

代码的问题是BBB和AAA的高耦合。
BBB 正在创建 AAA 的实例，但这意味着如果您需要 AAA 的另一个变体，它会计算 method1 () 有点不同(例如，对于某些类型的输入更有效)，你不能使用它，因为通过创建 BBB 的实例 - 你无法选择哪个将使用 AAA 的实现，使此类 (BBB) 不可重用。

这可以通过让 BBB 在构造函数中接收 AAA 的实例或 AbstractFactory 来解决。类，如果你需要隔离它的实例。

What I dont get is what is the problem exactly with dependencies and implementation details and having to change if another class changes

1. 它避免了在不复制粘贴大量代码的情况下重用现有代码，这是发生很多错误的地方。
2. 此外，假设您正在尝试计算 f(g(x))。
   现在，假设您有 3 种不同的“方式”来实现 f() 和 4 种不同的方式来实现 g()。
   如果你的类是高度耦合的，你将需要为每一种计算方式创建一个新类，所以你将不得不编写 3*4=12 个类。
   但是如果它们是解耦的，你只需要3+4=7个类。
   在大项目中，这种情况恰好会快速增长，以至于无法正确维护太多类。

When I have a reference of a class (and create a dependency) and call a public method, how am I then dependent on implementation details? Just because I call that method doesnt mean I know whats going on inside it...?

不，但是你依赖于类，如果你使用的那个方法改变了它的签名——你也需要改变你的代码，所以如果改变类 A , 也让你改变你的类(class)，你依赖于类(class) A。