前言

如果你涉及软件开发，可能会经常听到“高内聚，低耦合”这种概念型词语。我在第一次接触这种词语时，也抱有很大的疑问，但我发现百度上大部分都是高大上的词汇解释。

仔细通读这篇文章，你就能理解耦合性和内聚性的概念与关系。

WHY?

Why？如果你使用过面向对象的编程语言，初学者很容易：

1把所有代码都写到一个方法里。

当我翻回到我曾经写过的代码后，我绝望了。

1比如我们要获取一个用户的信息，我们需要先：
21. 在代码中填写数据库的地址、用户名、密码、表名
32. 加载SQL驱动
43. 执行语句
54. 获得结果

如果你只需要在一个方法里调用用户的信息，你可以把这四步的代码全部写到那个方法中。

但是如果我们有多个方法都要调用数据库呢？

把这段语句写四五六七八九遍？

不不不。不但你会抓耳挠腮，IDE都看不下去了。

1如果我们新建一个方法，专门用于读取用户的信息呢？
2在这个方法中，是上方执行语句的代码，但不同的是，我们使用其它方法调用该查询方法的时候，传入查询语句，这个方法就能返回给我们想要的值。

你只要将查询代码单独写成一个方法，当其它方法需要查询的时候，只需要调用这个查询方法并传入想查询的数据就可以了。

DO!

由于我不会用其它语言，所以这里使用Java进行演示。

首先看下面这串代码：

 1public class SimpleDemo {
 2    //由姓名获取某个用户的全部信息
 3    public void byName() {
 4        //1.创建驱动程序类对象
 5        Driver driver = new com.mysql.jdbc.Driver();
 6
 7        //设置用户名和密码
 8        Properties props = new Properties();
 9        props.setProperty("user", "root");
10        props.setProperty("password", "toor");
11
12        //2.连接数据库，返回连接对象
13        Connection conn = driver.connect(url, props);
14
15        String sql="select * from users where name = 'lilei'";
16        Statement pstmt = conn.createStatement();
17        ResultSet rs=pstmt.executeQuery(sql);
18        
19        System.out.println("结果为：" + rs.next());
20    }
21    
22    //由ID获取某个用户的全部信息
23    public void byID() {
24        //1.创建驱动程序类对象
25        Driver driver = new com.mysql.jdbc.Driver();
26
27        //设置用户名和密码
28        Properties props = new Properties();
29        props.setProperty("user", "root");
30        props.setProperty("password", "toor");
31
32        //2.连接数据库，返回连接对象
33        Connection conn = driver.connect(url, props);
34
35        String sql="select * from users where id = 1";
36        Statement pstmt = conn.createStatement();
37        ResultSet rs=pstmt.executeQuery(sql);
38
39        System.out.println("结果为：" + rs.next());
40    }
41    
42    //由年龄获取某个用户的全部信息
43    public void byAge() {
44        //1.创建驱动程序类对象
45        Driver driver = new com.mysql.jdbc.Driver();
46
47        //设置用户名和密码
48        Properties props = new Properties();
49        props.setProperty("user", "root");
50        props.setProperty("password", "toor");
51
52        //2.连接数据库，返回连接对象
53        Connection conn = driver.connect(url, props);
54
55        String sql="select * from users where age = 18";
56        Statement pstmt = conn.createStatement();
57        ResultSet rs=pstmt.executeQuery(sql);
58
59        System.out.println("结果为：" + rs.next());
60    }
61}

我们使用用户名、ID、年龄读取了三次信息，你会发现一件事：

重复代码太多！

如果我们稍加修改：

 1public class SimpleDemo {
 2    //执行数据库语句
 3    public ResultSet doSQL(String sql) {
 4        //1.创建驱动程序类对象
 5        Driver driver = new com.mysql.jdbc.Driver();
 6
 7        //设置用户名和密码
 8        Properties props = new Properties();
 9        props.setProperty("user", "root");
10        props.setProperty("password", "toor");
11
12        //2.连接数据库，返回连接对象
13        Connection conn = driver.connect(url, props);
14        Statement pstmt = conn.createStatement();
15        ResultSet rs=pstmt.executeQuery(sql);
16
17        return rs;
18    }
19
20    public void byName() {
21        ResultSet rs = doSQL("select * from users where name = 'lilei'");
22        System.out.println("结果为：" + rs.next());
23    }
24
25    public void byID() {
26        ResultSet rs = doSQL("select * from users where id = 1");
27        System.out.println("结果为：" + rs.next());
28    }
29
30    public void byAge() {
31        ResultSet rs = doSQL("select * from users where age = 18");
32        System.out.println("结果为：" + rs.next());
33    }
34}

利用传值，我们将大部分冗余代码进行了清理。

后语

概念

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

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

那么内聚就是：

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

总结

“高内聚，低耦合”是面向对象编程的基本原则，我们能获得更好的维护性和更佳的可读性。