java框架模式_低耦合高内聚法则

低耦合高内聚法则

定义：一个对象应该对其他对象保持最少的了解。

问题由来：类与类之间的关系越来越密切，耦合度越来越大，当一个类发生改变时，对另外一个类的影响也越大.

解决方案：尽量降低类与类之间的耦合.

自从我们接触到编程开始，就知道了软件设计的总的原则，低耦合，高内聚，无论是面向对象或者面向过程，耦合度尽量低，才能提高代码的复用率。但是编程怎么编程低耦合呢？

无论逻辑怎么复杂，对于依赖的类来说，都尽量将逻辑封装在类的内部，对外除了提供的public方法，不对外泄露任何信息。还有一个更加简单的定义：只与直接的朋友通信。首先解释一下什么是直接的朋友；每个对象都会与其他对象发生耦合关系，我们就说这两个对象之间有耦合关系，我们就说这两个对象有朋友关系，耦合发生的方式有很多，依赖，关联，组合，聚合等等。其中，我们称出现成员变量，方法参数，方法返回值的类称为直接的朋友，而出现在局部变量中的类为不是直接的朋友，也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部；

 

举一个例子，在一所学校，里面有老师若干名，依次编号。下面有学生若干名，一次编号。现在要求打印出所有的老师和学生的ID.

先来违反低耦合高内聚原则

代码如下。

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());

      }

     

   }

  

}

 

public classClient {

 publicstaticvoidmain(String[] args) {

   TeacherManagetm=newTeacherManage();

   tm.printAllPerson(new StudentManage()); 

    

}

}

现在这个设计的主要问题出现在TeacherManage类中，根据低耦合高内聚法则，只与直接的朋友进行通信，而Student类并不是TeacherManage类中的直接朋友，应避免类中出现这样非直接朋友关系的耦合。

修改之后代码如下：

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的方法，老师直接来调用即可。从而避免了与学生发生耦合。低耦合高内聚原则的初衷是降低了类之间的耦合，由于每个类减少了不必要的依赖，因此的确可以降低耦合关系，但是凡事有个度，虽然可以避免与非直接的类通信，但是要通信，必然会通过一个“中介”来发生关系。采用此法则可以做到结构清晰，高内聚低耦合、