内聚力和耦合之间的区别

Question

内聚力和耦合力有什么区别？

耦合和内聚如何导致软件设计的好坏？

有哪些示例概述了两者之间的差异及其对整体代码质量的影响？

Answer 1

内聚指的是类（或模块）可以做什么。低凝聚力意味着班级会采取各种各样的行动——范围广泛，不专注于应该做的事情。高内聚意味着类专注于它应该做的事情，即只关注与类意图相关的方法。

低内聚示例：

-------------------
| Staff           |
-------------------
| checkEmail()    |
| sendEmail()     |
| emailValidate() |
| PrintLetter()   |
-------------------

高内聚示例：

----------------------------
| Staff                   |
----------------------------
| -salary                 |
| -emailAddr              |
----------------------------
| setSalary(newSalary)    |
| getSalary()             |
| setEmailAddr(newEmail)  |
| getEmailAddr()          |
----------------------------

至于耦合，它指的是两个类/模块彼此之间的相关或依赖程度。对于低耦合类，更改一个类中的主要内容不应影响另一个类。高耦合会使代码难以更改和维护；由于课程紧密结合在一起，做出改变可能需要对整个系统进行改造。

好的软件设计具有高内聚和低耦合。

Answer 2

模块内的高内聚和模块之间的低耦合通常被认为与面向对象编程语言的高质量有关。

例如，每个Java类内部的代码必须具有较高的内部内聚性，但与其他Java类中的代码尽可能松散耦合。

Meyer 的面向对象的软件构建（第 2 版） 的第 3 章对这些问题进行了精彩的描述。

Answer 3

内聚表明软件元素的职责的相关性和集中程度。

耦合是指软件元素与其他元素连接的强度。

软件元素可以是类、包、组件、子系统或系统。在设计系统时，建议使用具有高内聚并支持低耦合的软件元素。

内聚力低会导致类难以维护、理解并降低可重用性。同样，高耦合会导致类紧密耦合，并且更改往往不是非本地的、难以更改并减少重用。

我们可以假设一个场景，我们正在设计一个典型的可监控ConnectionPool，并满足以下要求。请注意，对于像 ConnectionPool 这样的简单类来说，它可能看起来太多了，但基本目的只是为了用一些东西来演示低耦合和高内聚简单的例子，我认为应该有帮助。

1. 支持获取连接
2. 释放连接
3. 获取有关连接与使用计数的统计信息
4. 获取有关连接与时间的统计信息
5. 将连接检索和释放信息存储到数据库中以供稍后报告。

在低内聚的情况下，我们可以通过将所有这些功能/职责强制填充到一个类中来设计一个ConnectionPool类，如下所示。我们可以看到这个类负责连接管理、与数据库交互以及维护连接统计信息。

通过高内聚，我们可以在各个类之间分配这些职责，并使其更易于维护和重用。

为了演示低耦合，我们将继续使用上面的高内聚ConnectionPool图。如果我们看一下上图，虽然它支持高内聚，但 ConnectionPool 与 ConnectionStatistics 类紧密耦合，并且 PersistentStore 直接与它们交互。为了减少耦合，我们可以引入一个ConnectionListener接口，让这两个类实现该接口，并让它们向ConnectionPool类注册。 ConnectionPool 将循环访问这些侦听器，并通知它们连接获取和释放事件，并减少耦合。

注释/文字或警告：对于这个简单的场景，它可能看起来有些过大，但如果我们想象一个实时场景，我们的应用程序需要与多个第三方服务交互完成交易：直接将我们的代码与第三方服务耦合意味着第三方服务中的任何更改都可能导致我们的代码在多个位置发生更改，相反，我们可以使用 Facade 与这些服务进行交互内部有多个服务，对服务的任何更改都会成为Facade 的本地内容，并强制与第三方服务实现低耦合。

Answer 4

简而言之，内聚表示代码库的一部分形成逻辑上单个原子单元的程度。另一方面，耦合表示单个单元对其他单元的依赖程度。换句话说，它是两个或多个单元之间的连接数量。数量越少，耦合度越低。

本质上，高内聚意味着将代码库中彼此相关的部分保留在一个地方。同时，低耦合是指尽可能地分离代码库中不相关的部分。

从内聚和耦合角度来看的代码类型：

理想是遵循准则的代码。它是松散耦合且高度内聚的。我们可以用这张图片来说明这样的代码：

God Object 是引入高内聚和高耦合的结果。它是一种反模式，基本上代表一段代码可以同时完成所有工作：

当不同类或模块之间的边界选择不当时，就会发生选择不当

破坏性解耦是最有趣的一种。当程序员试图将代码库解耦得太多以至于代码完全失去焦点时，有时会发生这种情况：

了解更多此处

Answer 5

增加内聚性和减少耦合确实会带来良好的软件设计。

内聚对您的功能进行分区，使其简洁且最接近与其相关的数据，而解耦则确保功能实现与系统的其余部分隔离。

解耦允许您在不影响软件其他部分的情况下更改实现。

内聚确保实现功能更加具体，同时更易于维护。

减少耦合、增加内聚最有效的方法是按接口设计。

也就是说，主要的功能对象应该只通过它们实现的接口来“了解”彼此。接口的实现自然会引入内聚力。

虽然在某些情况下不现实，但它应该是一个可以遵循的设计目标。

示例（非常粗略）：

public interface IStackoverFlowQuestion
      void SetAnswered(IUserProfile user);
      void VoteUp(IUserProfile user);
      void VoteDown(IUserProfile user);
}

public class NormalQuestion implements IStackoverflowQuestion {
      protected Integer vote_ = new Integer(0);
      protected IUserProfile user_ = null;
      protected IUserProfile answered_ = null;

      public void VoteUp(IUserProfile user) {
           vote_++;
           // code to ... add to user profile
      }

      public void VoteDown(IUserProfile user) {
          decrement and update profile
      }

      public SetAnswered(IUserProfile answer) {
           answered_ = answer
           // update u
      }
}

public class CommunityWikiQuestion implements IStackoverflowQuestion {
     public void VoteUp(IUserProfile user) { // do not update profile }
     public void VoteDown(IUserProfile user) { // do not update profile }
     public void SetAnswered(IUserProfile user) { // do not update profile }
}

在代码库的其他地方，您可以有一个模块来处理问题，无论它们是什么：

public class OtherModuleProcessor {
    public void Process(List<IStackoverflowQuestion> questions) {
       ... process each question.
    }
}

Answer 6

对内聚的最好解释来自Uncle Bob的《干净的代码》：

类应该有少量的实例变量。类的每个方法都应该操作一个或多个这些变量。 一般来说，方法操作的变量越多，该方法与其类的内聚性就越高。每个方法使用每个变量的类是最大内聚的。

一般来说，创建这种最大内聚的类既不可取也不可能；另一方面，我们希望凝聚力较高。当内聚性很高时，意味着类的方法和变量是相互依赖的，并作为一个逻辑整体挂在一起。

保持函数较小和参数列表较短的策略有时会导致方法子集使用的实例变量的激增。当这种情况发生时，几乎总是意味着至少有一个其他班级试图脱离更大的班级。您应该尝试将变量和方法分成两个或多个类，以便新类更具凝聚力。

Answer 7

软件工程中的内聚是指某个模块的元素所属的程度。因此，它是衡量软件模块源代码所表达的每项功能的相关程度的指标。

简而言之，耦合是一个组件（再次想象一个类，尽管不一定）对另一个组件的内部工作或内部元素了解多少，即它对另一个组件有多少了解。

我写了一篇关于此的博客文章，如果您想阅读带有示例和图纸的更多细节。我认为它回答了你的大部分问题。

Answer 8

在软件设计中，内聚和耦合是关系到代码质量和可维护性的两个重要概念。

高内聚性：

• 高内聚性意味着所有相关项目都应该联系在一起，例如汽车、厨房
• 汽车汽车：汽车的所有元素都紧密相连，并协同工作以实现单一目的– 驾驶。发动机、车轮、变速箱和其他部件都必须协调运转，汽车才能有效运行。这种高水平的凝聚力使汽车高效可靠。
• 厨房：同样，厨房也展现出高凝聚力。器具、用具和配料都直接有助于准备和烹饪食物的单一目的。这使得厨房变得精简并促进工作流程顺利进行。

低耦合：

• 低耦合意味着模块不应该非常高地结合在一起，因为这会导致连锁反应。例如，建造房屋
• 建造房屋：建造房屋所涉及的各种模块——地基、框架、电气、管道——都是低耦合的好例子。它们可以以最少的协调独立工作，并且一个模块中的问题（例如管道泄漏）不一定会影响其他模块。这使得施工更加高效并避免级联故障。

Answer 9

我认为差异可以概括如下：

• 内聚性代表代码库的一部分形成逻辑上单个原子单元的程度。
• 耦合度表示单个单元与其他单元的独立程度。
• 在不损害内聚性的情况下实现完全解耦是不可能的，反之亦然。

在这篇博文中，我更详细地介绍了它。

Answer 10

内聚表示模块的相对功能强度。

• 内聚模块执行单个任务，几乎不需要
  与程序其他部分中的其他组件进行交互。规定
  简而言之，一个内聚模块应该（理想地）只做一件事。

• „传统观点：

  模块的“一心一意”

• „OO观点：

  „内聚意味着组件或类仅封装彼此密切相关以及与类或组件本身密切相关的属性和操作

• „内聚级别

  „功能性

  „图层

  „沟通

  „顺序

  „程序

  „颞部

  „效用

耦合是模块之间相对相互依赖性的指示。

• 耦合度取决于模块之间的接口复杂度，
  对模块进行条目或引用的点以及哪些数据
  跨接口传递。

• 传统观点：
  组件与其他组件以及外部世界的连接程度

• OO 视图：类之间连接程度的定性测量

• 耦合级别

  „内容

  „常见

  „控制

  „邮票

  „数据

  „例行调用

  „类型使用

  „包含或导入

  „外部#

Answer 11

内聚这个术语在软件设计中的含义确实有点违反直觉。

内聚力的通俗含义是指某种东西能很好地粘在一起、团结在一起，其特点是像分子吸引力一样具有很强的键合力。然而在软件设计中，这意味着争取一个理想情况下只做一件事的类，因此甚至不涉及多个子模块。

或许我们可以这样想。当一个部分是唯一的部分（只做一件事并且不能进一步分解）时，它具有最大的凝聚力。这正是软件设计所需要的。内聚只是“单一责任”或“关注点分离”的另一个名称。

术语耦合非常直观，这意味着当一个模块不依赖于太多其他模块并且它所连接的模块可以轻松替换时，例如遵守liskov替换原则 。

Answer 12

耦合 = 两个模块之间的交互/关系...
内聚 = 模块内两个元素之间的交互。

一个软件是由很多模块组成的。模块由元素组成。将模块视为程序。程序中的函数是一个元素。

在运行时，一个程序的输出用作另一个程序的输入。这称为模块到模块交互或进程到进程通信。这也称为耦合。

在单个程序中，一个函数的输出被传递给另一个函数。这称为模块内元素的交互。这也称为内聚力。

示例：

耦合 = 两个不同家庭之间的沟通...
凝聚力 = 家庭中父亲、母亲、孩子之间的沟通。

Answer 13

简单地说，内聚意味着一个类应该代表一个单一的概念。

如果所有类功能都与类所代表的概念相关，则类的公共接口是内聚的。
例如，不是使用 CashRegister 类，而是使用 CashRegister 和 Coin 功能内聚使其分为 2 个类 - CashRegister 和 Coin 类。

在耦合中，一个类依赖于另一个类，因为它使用该类的对象。

高耦合的问题是它会产生副作用。一个类中的一项更改可能会导致另一个类中出现意外错误，并可能破坏整个代码。

一般来说，高内聚、低耦合被认为是高质量的OOP。

Answer 14

理论差异

内聚 内

• 聚是模块相对功能强度的指示。
• 内聚模块执行单一任务，几乎不需要与其他模块交互
  程序其他部分的组件。
• 具有高内聚和低耦合的模块被认为是功能独立的
  其他模块的。

内聚性的分类

1.同时发生的 2.逻辑发生的 3.时间发生的 4.过程发生的 5.通信发生的 6.顺序发生的 7.功能

耦合的

• 耦合是模块之间相对相互依赖的表现。
• 两个模块之间的耦合程度取决于它们的接口复杂性。

Answer 15

简单来说，
内聚是“一起改变的代码保持在一起”。
耦合是“对一个组件的更改需要对另一个组件的更改”。

内聚适用于边界内的代码，耦合适用于跨边界的代码。

如果内聚性强、耦合性低，那么系统是稳定的。这是微服务世界的口头禅。

不同类型的耦合：（从松散到强）

• 域耦合 - 一个微服务需要与另一个微服务交互（以使用功能）
• 传递耦合 - 一个微服务将数据传递到另一个微服务纯粹是为了供另一个下游服务使用
• 公共耦合- 2 个微服务使用一组通用数据（如共享数据库或缓存）
• 内容耦合 - 上游服务更改下游服务的内部状态