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

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

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

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

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

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

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

例子(非常粗略):

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

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

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视图:类之间连接程度的定性度量 耦合水平 内容 常见 控制 邮票 数据 程序调用 类型使用 包含或导入 外部#

在软件工程中，内聚是指某个模块的元素属于一起的程度。因此，它是软件模块的源代码所表达的每个功能之间相关性的一种度量。

简单地说，耦合就是一个组件(再一次，想象一个类，尽管不一定)对另一个组件的内部工作方式或内部元素的了解程度，即它对另一个组件的了解程度。

我写了一篇关于这个的博客文章，如果你想用例子和图表来阅读更多的细节。我想它回答了你的大部分问题。

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

软件是由许多模块组成的。模块由元素组成。把一个模块看作一个程序。程序中的函数是一个元素。

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

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

例子:

耦合=两个不同家庭之间的交流…… 凝聚力=家庭中父亲、母亲和孩子之间的交流。

cohesion refers all about how a single class is designed. Cohesion is the Object Oriented principle most closely associated with making sure that a class is designed with a single, well-focused purpose. The more focused a class is, the cohesiveness of that class is more. The advantages of high cohesion is that such classes are much easier to maintain (and less frequently changed) than classes with low cohesion. Another benefit of high cohesion is that classes with a well-focused purpose tend to be more reusable than other classes.

在上图中，我们可以看到，在低内聚情况下，只有一个类负责执行大量不相同的作业，这降低了可重用性和维护的机会。但是在高内聚的情况下，所有的作业都有一个单独的类来执行特定的作业，这样可以获得更好的可用性和可维护性。

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

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

Meyer的面向对象软件构建(第二版)的第3章对这些问题进行了很好的描述。