定义:一个对象应该对其他对象保持最少的了解。
问题由来:类与类之间的关系越来越密切,耦合度越来越大,当一个类发生改变时,对另外一个类的影响也越大.
解决方案:尽量降低类与类之间的耦合.
自从我们接触到编程开始,就知道了软件设计的总的原则,低耦合,高内聚,无论是面向对象或者面向过程,耦合度尽量低,才能提高代码的复用率。但是编程怎么编程低耦合呢?
无论逻辑怎么复杂,对于依赖的类来说,都尽量将逻辑封装在类的内部,对外除了提供的public方法,不对外泄露任何信息。还有一个更加简单的定义:只与直接的朋友通信。首先解释一下什么是直接的朋友;每个对象都会与其他对象发生耦合关系,我们就说这两个对象之间有耦合关系,我们就说这两个对象有朋友关系,耦合发生的方式有很多,依赖,关联,组合,聚合等等。其中,我们称出现成员变量,方法参数,方法返回值的类称为直接的朋友,而出现在局部变量中的类为不是直接的朋友,也就是说,陌生的类最好不要作为局部变量的形式出现在类的内部;
举一个例子,在一所学校,里面有老师若干名,依次编号。下面有学生若干名,一次编号。现在要求打印出所有的老师和学生的ID.
先来违反低耦合高内聚原则
代码如下。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
package test1; import java.util.ArrayList; import java.util.List; class Teacher{ privateString id; publicvoidsetId(String id) { this .id=id; } publicString getId() { return id; } } class Student{ private String id; public void setId(String id) { this .id=id; } public String getId() { return id; } } class StudentManage{ publicList<Student> getAllStudent() { List<Student> list=newArrayList<Student>(); for ( int i= 0 ;i< 100 ;i++) { Student student= new Student(); student.setId( "学生学号是" +i); list.add(student); } return list; } } class TeacherManage { publicList<Teacher> getAllTeacher() { List<Teacher> list=newArrayList<Teacher>(); for (inti= 0 ;i< 100 ;i++) { Teacher teacher = new Teacher(); teacher.setId( "老师编号" +i); list.add(teacher); } return list; } public void printAllPerson(StudentManagestudentmanager) { List<Student>list1=studentmanager.getAllStudent(); for (Student s:list1) { System.out.println(s.getId()); } List<Teacher>list2= this .getAllTeacher(); for (Teacher t:list2) { System.out.println(t.getId()); } } } |
1
2
3
4
5
6
|
public classClient { publicstaticvoidmain(String[] args) { TeacherManagetm=newTeacherManage(); tm.printAllPerson( new StudentManage()); } } |
现在这个设计的主要问题出现在TeacherManage类中,根据低耦合高内聚法则,只与直接的朋友进行通信,而Student类并不是TeacherManage类中的直接朋友,应避免类中出现这样非直接朋友关系的耦合。
修改之后代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
package test2; import java.util.ArrayList; import java.util.List; class Teacher{ privateString id; publicvoidsetId(String id) { this .id=id; } publicString getId() { return id; } } class Student{ private String id; public void setId(String id) { this .id=id; } public String getId() { return id; } } class StudentManage{ publicList<Student> getAllStudent() { List<Student> list=newArrayList<Student>(); for ( int i= 0 ;i< 100 ;i++) { Student student= new Student(); student.setId( "学生学号是" +i); list.add(student); } return list; } public void printAllStudent() { List<Student>list1= this .getAllStudent(); for (Student s:list1) { System.out.println(s.getId()); } } } class TeacherManage { publicList<Teacher> getAllTeacher() { List<Teacher> list=newArrayList<Teacher>(); for (inti= 0 ;i< 100 ;i++) { Teacher teacher = new Teacher(); teacher.setId( "老师编号" +i); list.add(teacher); } return list; } publicvoidprintAllTeacher() { List<Teacher> list2= this .getAllTeacher(); for (Teacher t:list2) { System.out.println(t.getId()); } } } public classClient { publicstaticvoidmain(String[] args) { TeacherManagetm=newTeacherManage(); tm.printAllTeacher(); StudentManagesm=newStudentManage(); sm.printAllStudent(); } } |
修改后,学生新增加了学生ID的方法,老师直接来调用即可。从而避免了与学生发生耦合。低耦合高内聚原则的初衷是降低了类之间的耦合,由于每个类减少了不必要的依赖,因此的确可以降低耦合关系,但是凡事有个度,虽然可以避免与非直接的类通信,但是要通信,必然会通过一个“中介”来发生关系。采用此法则可以做到结构清晰,高内聚低耦合、
耦合性与内聚性是模块独立性的两个定性标准,将软件系统划分模块时,尽量做到高内聚低耦合,提高模块的独立性,为设计高质量的软件结构奠定基础。
有个例子很容易明白:一个程序有50个函数,这个程序执行得非常好;然而一旦你修改其中一个函数,其他49个函数都需要做修改,这就是高耦合的后果。
总结
以上就是本文关于高内聚低耦合法则实例代码解析的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!
原文链接:http://blog.csdn.net/lijia503102319/article/details/50259835