结构化设计（内聚）

结构化设计中的内聚是指一个模块内部各成分之间相互关联的紧密程度，它是衡量模块独立性的一个重要指标。高内聚意味着模块内部的各个部分联系紧密、功能单一，这样的模块更容易理解、维护和复用。以下是常见的内聚类型，按照内聚程度从低到高排列：

1.偶然内聚

• 定义：模块内的各成分之间没有实质性的联系，只是因为偶然的原因被组合在一个模块中。例如，一个模块里包含了计算圆面积、打印欢迎信息和读取文件这三个功能，它们之间没有内在的逻辑关联。
• 代码示例：

  class RandomFunctions {
      public static void main(String[] args) {
          // 计算圆的面积
          double radius = 5;
          double area = Math.PI * radius * radius;
          System.out.println("圆的面积是: " + area);
  
          // 打印欢迎信息
          System.out.println("欢迎使用本系统！");
  
          // 读取文件
          try {
              java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.FileReader("test.txt"));
              String line;
              while ((line = reader.readLine()) != null) {
                  System.out.println(line);
              }
              reader.close();
          } catch (java.io.FileNotFoundException e) {
              System.out.println("文件未找到");
          } catch (java.io.IOException e) {
              e.printStackTrace();
          }
      }
  }

2.逻辑内聚

• 定义：模块内的各成分在逻辑上属于同一类功能，但具体的执行动作不同。例如，一个模块根据不同的输入参数执行不同的操作，如打印不同类型的报表，包括日报表、周报表和月报表。
• 代码示例：

  class PrintReport {
      public static void printReport(String reportType) {
          switch (reportType) {
              case "daily":
                  System.out.println("打印日报表");
                  break;
              case "weekly":
                  System.out.println("打印周报表");
                  break;
              case "monthly":
                  System.out.println("打印月报表");
                  break;
              default:
                  System.out.println("无效的报表类型");
          }
      }
  
      public static void main(String[] args) {
          printReport("daily");
      }
  }

3.时间内聚

• 定义：模块内的各成分需要在同一时间段内执行。例如，一个初始化模块，在系统启动时需要同时进行变量初始化、配置文件加载和日志记录器的初始化。
• 代码示例：

  class SystemInitialization {
      public static int counter;
  
      public static void main(String[] args) {
          // 初始化变量
          counter = 0;
  
          // 加载配置文件
          try {
              java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.FileReader("config.txt"));
              String config = reader.readLine();
              System.out.println("加载配置文件: " + config);
              reader.close();
          } catch (java.io.FileNotFoundException e) {
              System.out.println("配置文件未找到");
          } catch (java.io.IOException e) {
              e.printStackTrace();
          }
  
          // 初始化日志记录器
          System.out.println("初始化日志记录器");
      }
  }

4.过程内聚

• 定义：模块内的各成分按照特定的顺序执行，通常是完成一个特定的业务流程。例如，一个订单处理模块，按照接收订单、验证订单信息、计算总价、更新库存的顺序执行。
• 代码示例：

  class ProcessOrder {
      public static void processOrder() {
          // 接收订单
          System.out.println("接收订单");
  
          // 验证订单信息
          System.out.println("验证订单信息");
  
          // 计算总价
          System.out.println("计算总价");
  
          // 更新库存
          System.out.println("更新库存");
      }
  
      public static void main(String[] args) {
          processOrder();
      }
  }

5.通信内聚

• 定义：模块内的各成分都使用相同的数据或产生相同的数据。例如，一个模块用于处理学生成绩，它会读取学生的成绩数据，然后计算平均分和最高分，这些操作都围绕着学生成绩数据进行。
• 代码示例：

  import java.util.Arrays;
  
  class ProcessScores {
      public static void main(String[] args) {
          int[] scores = {85, 90, 78, 92, 88};
  
          // 计算平均分
          int sum = 0;
          for (int score : scores) {
              sum += score;
          }
          double average = (double) sum / scores.length;
          System.out.println("平均分: " + average);
  
          // 计算最高分
          int maxScore = Arrays.stream(scores).max().getAsInt();
          System.out.println("最高分: " + maxScore);
      }
  }

6.顺序内聚

• 定义：模块内的各成分之间存在着数据的顺序依赖关系，前一个成分的输出是后一个成分的输入。例如，一个数据处理模块，先对数据进行过滤，然后对过滤后的数据进行排序。
• 代码示例：

  import java.util.Arrays;
  import java.util.stream.IntStream;
  
  class DataProcessing {
      public static void main(String[] args) {
          int[] data = {5, 3, 8, 1, 2};
  
          // 过滤数据
          int[] filteredData = IntStream.of(data).filter(x -> x > 2).toArray();
          System.out.println("过滤后的数据: " + Arrays.toString(filteredData));
  
          // 排序数据
          Arrays.sort(filteredData);
          System.out.println("排序后的数据: " + Arrays.toString(filteredData));
      }
  }

7.功能内聚

• 定义：模块内的各成分共同完成一个单一的、明确的功能，模块的所有操作都紧密围绕这个功能展开。例如，一个计算两个数之和的模块。
• 代码示例：

  class AddNumbers {
      public static int addNumbers(int a, int b) {
          return a + b;
      }
  
      public static void main(String[] args) {
          int result = addNumbers(3, 5);
          System.out.println("两数之和: " + result);
      }
  }

在结构化设计中，应尽量追求高内聚，特别是功能内聚，这样可以提高模块的独立性和可维护性，降低模块之间的耦合度。