内聚性是一个模块相对功能强度的指示。

A cohesive module performs a single task, requiring little interaction with other components in other parts of a program. Stated simply, a cohesive module should (ideally) do just one thing. Conventional view: the “single-mindedness” of a module OO view: cohesion implies that a component or class encapsulates only attributes and operations that are closely related to one another and to the class or component itself Levels of cohesion Functional Layer Communicational Sequential Procedural Temporal utility

耦合表示模块之间的相对相互依赖。

耦合取决于模块之间的接口复杂性 指向一个模块的条目或引用，以及什么数据 通过接口传递。 传统观点: 一个组件与其他组件和外部世界的连接程度 OO视图:类之间连接程度的定性度量 耦合水平 内容 常见 控制 邮票 数据 程序调用 类型使用 包含或导入 外部#

提高内聚性和降低耦合确实会带来好的软件设计。

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

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

内聚性确保实现更特定于功能，同时更容易维护。

减小耦合、提高内聚的最有效方法是采用界面设计。

也就是说，主要的功能对象只能通过它们实现的接口相互“认识”。接口的实现自然会引入内聚性。

虽然在某些场景中不太现实，但这应该是一个设计目标。

例子(非常粗略):

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.
    }
}

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

聚合力通常的意思是某物粘在一起很好，是统一的，其特征是像分子吸引力一样的强结合。然而，在软件设计中，这意味着力求类在理想情况下只做一件事，因此甚至不涉及多个子模块。

也许我们可以这样想。当一个部分是唯一的部分(只做一件事并且不能进一步分解)时，它具有最大的内聚性。这就是软件设计所需要的。内聚只是“单一责任”或“关注点分离”的另一种说法。

术语耦合是非常直观的，这意味着当一个模块不依赖于太多其他模块时，它所连接的那些模块可以很容易地被替换，例如遵循利斯科夫替换原理。

关于内聚的最好解释来自Bob叔叔的《Clean Code》:

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

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

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

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

如果类的所有特性都与类所代表的概念相关，那么类的公共接口就是内聚的。 例如，与其拥有CashRegister类，不如拥有CashRegister和Coin功能，将其整合为2个类- CashRegister和Coin类。

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

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

通常，高内聚和低耦合被认为是高质量的OOP。

内聚指的是类(或模块)可以做什么。低内聚意味着这个类会做各种各样的动作——它很宽泛，不关注它应该做什么。高内聚意味着类专注于它应该做的事情，即只有与类的意图相关的方法。

低内聚的例子:

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

高内聚的例子:

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

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

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