Java学习之浅析高内聚低耦合

•前言

　　如果你涉及软件开发，可能会经常听到 “高内聚，低耦合” 这种概念型词语。

　　可是，何为 “高内聚，低耦合” 呢？

•概念

　　“高内聚，低耦合” 是相对于代码而言，一个项目中：

• 每个模块之间相互联系的紧密程度，模块之间联系越紧密，则耦合性越高，模块的独立性就越差，反之同理；
• 一个模块中各个元素之间的联系的紧密程度，如果各个元素（语句、程序段）之间的联系程度越高，则内聚性越高，即 “高内聚” ；

　　如：一个项目中有20个方法调用良好，但是要修改了其中一个，另外的19个都要进行修改，这就是高耦合，独立性太差；

　　现在的软件结构设计，都会要求 “高内聚，低耦合”，来保证软件的高质量！

•通过代码直观感受

　　假设有一个数组  a[] = {1,2,3,4,5} ；

　　现在需要你通过代码计算公式

$(a[0]+a[1]+\cdots+a[4])\cdot(a[0]+a[1]+\cdots+a[3])\cdot_{\cdots}\cdot a[0]$

　　的值，你可以这么编写代码：

static int[] a = new int[] {1,2,3,4,5};

    public static void main(String[] args) {

        //计算a[0]+a[1]+a[2]+a[3]+a[4]
        int sum1 = 0;
        for(int i = 0;i <= 4;i++) {
            sum1 += a[i];
        }

        //计算a[0]+a[1]+a[2]+a[3]
        int sum2 = 0;
        for(int i = 0;i <= 3;i++) {
            sum2 += a[i];
        }

        //计算a[0]+a[1]+a[2]
        int sum3 = 0;
        for(int i = 0;i <= 2;i++) {
            sum3 += a[i];
        }

        //计算a[0]+a[1]
        int sum4 = 0;
        for(int i = 0;i <= 1;i++) {
            sum4 += a[i];
        }

        //计算a[0]
        int sum5 = 0;
        for(int i = 0;i <= 0;i++) {
            sum5 += a[i];
        }

        //计算乘积
        int sum = sum1*sum2*sum3*sum4*sum5;
        System.out.println(sum);
    }

}

　　通过分析代码你会发现：重复代码太多！

　　如果我们把重复的代码提取出来，会怎么样呢？

　　稍加修改一下：

public class SimpleDemo {

    static int[] a = new int[] {1,2,3,4,5};

    public static void main(String[] args) {

        //计算a[0]+a[1]+a[2]+a[3]+a[4]
        int sum1 = Sum(0, 4);

        //计算a[0]+a[1]+a[2]+a[3]
        int sum2 = Sum(0, 3);

        //计算a[0]+a[1]+a[2]
        int sum3 = Sum(0, 2);

        //计算a[0]+a[1]
        int sum4 = Sum(0, 1);

        //计算a[0]
        int sum5 = Sum(0, 0);

        //计算乘积
        int sum = sum1*sum2*sum3*sum4*sum5;
        System.out.println(sum);
    }

    public static int Sum(int x,int y) {
        int sum = 0;
        for(int i = x;i <= y;i++) {
            sum += a[i];
        }
        return sum;
    }
}

　　通过代码的复用，我们将大部分冗余代码进行了清理。

•小结

　　讲了这么多，你大概猜到耦合是什么意思了：

• 将一串代码模块化(即封装为不同方法)，每个模块(方法)都有自己的功能
• 封装方法越多，耦合度越低
• 模块与模块之间接口的复杂程度，模块之间联系越复杂，耦合度越高

　　那么内聚就是：

• 每个模块(方法)相互分离的情况下，修改了某模块(方法)其中的某些代码，但并不影响和其它模块的通讯(即高内聚)
• 每个模块尽可能独立完成自己的功能，不依赖于模块外部的代码。

•声明

参考资料

• 【“高内聚 ，低耦合”到底是什么意思？】
• 【大白话之耦合性：什么是耦合性和内聚性？用编程语言实例讲解！】