设计模式—— 五

public class GroupLeader {

//清查女生数量

public void countGirls(List listGirls){

System.out.println(“女生数量是：”+listGirls.size());

}

}

女生类:

public class Girl {

}

场景类:

public class Client {

public static void main(String[] args) {

Teacher teacher= new Teacher();

//老师发布命令

teacher.commond(new GroupLeader());

}

}

运行结果：

女生数量是：20

体育委员按照老师的要求对女生进行了清点，并得出了数量。这个程序有什么问题，首先确定Teacher类有几个朋友类，它仅有一个朋友类—— GroupLeader。为什么Girl不是朋友类呢？Teacher也对它产生了依赖关系呀！朋友类的定义是 这样的：出现在成员变量、方法的输入输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类，而Girl这个类就是出现在commond方法体内，因此不属于Teacher类的 朋友类。迪米特法则告诉我们一个类只和朋友类交流，但是刚刚定义的commond方法却 与Girl类有了交流，声明了一个List动态数组，也就是与一个陌生的类Girl有了交流， 这样就破坏了Teacher的健壮性。方法是类的一个行为，类竟然不知道自己的行为与其他类 产生依赖关系，这是不允许的，严重违反了迪米特法则。

[](()遵循迪米特法则的定义

现在根据迪米特法则进行改造，去掉Teacher对Girl类的依赖关系。

5-2：修改后的老师要求清点女生类图

修改后的老师类:

public class Teacher {

//老师对学生发布命令，清一下女生

public void commond(GroupLeader groupLeader){

//告诉体育委员开始执行清查任务

groupLeader.countGirls();

}

}

修改后的体育委员类：

public class GroupLeader { 《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》无偿开源 威信搜索公众号【编程进阶路】

private List listGirls; //传递全班的女生进来

public GroupLeader(List _listGirls){

this.listGirls = _listGirls;

}

//清查女生数量

public void countGirls(){

System.out.println(“女生数量是：”+this.listGirls.size());

}

}

修改后的场景类：

public class Client {

public static void main(String[] args) {

//产生一个女生群体

List listGirls = new ArrayList();

//初始化女生

for(int i=0;i<20;i++){

listGirls.add(new Girl());

}

Teacher teacher= new Teacher();

//老师发布命令

teacher.commond(new GroupLeader(listGirls));

}

}

把Teacher中对List的初始化移动到了场景类中，同时在GroupLeader中增加了对Girl的注入，避开了Teacher类对陌生类Girl的访问，降低了系统间的耦合，提高了系统的健壮性。

[](()2. 朋友间也是有距离的

---

朋友类之间可以交流，但也不能无话不谈。

以安装软件为例：第一步是确认是否安装，第二步确认 License，再然后选择安装目录……这是一个典型的顺序执行动作，具体到程序中就是：调用 一个或多个类，先执行第一个方法，然后是第二个方法，根据返回结果再来看是否可以调用 第三个方法，或者第四个方法。

[](()不遵循迪米特原则的设计

5-3：软件安装过程类图

导向类:

定义步骤方法。

public class Wizard {

private Random rand = new Random(System.currentTimeMillis());

//第一步

public int first(){

System.out.println(“执行第一个方法…”);

return rand.nextInt(100);

}

//第二步

public int second(){

System.out.println(“执行第二个方法…”);

return rand.nextInt(100);

}

//第三个方法

public int third(){

System.out.println(“执行第三个方法…”);

return rand.nextInt(100);

}

}

软件安装InstallSoftware类:

public class InstallSoftware {

public void installWizard(Wizard wizard){

int first = wizard.first();

//根据first返回的结果，看是否需要执行second

if(first>50){

int second = wizard.second();

if(second>50){

int third = wizard.third();

if(third >50){

wizard.first();

}

}

}

}

}

场景类:

public class Client {

public static void main(String[] args) {

InstallSoftware invoker = new InstallSoftware();

invoker.installWizard(new Wizard());

}

}

这个程序有什么问题呢？

Wizard类把太多的方法暴露给InstallSoftware类，两者的朋友关系太亲密了，耦合关系变得异 常牢固。如果要将Wizard类中的first方法返回值的类型由int改为boolean，就需要修改 InstallSoftware类，从而把修改变更的风险扩散开了。因此，这样的耦合是极度不合适的。

[](()遵循迪米特原则的设计

5-4：重构后的软件安装过程类图

修改后的导向类：

在Wizard类中增加一个installWizard方法，对安装过程进行封装，同时把原有的三个 public方法修改为private方法。将三个步骤的访问权限修改为private，同时把InstallSoftware中的方法installWizad移动到 Wizard方法中。通过这样的重构后，Wizard类就只对外公布了一个public方法，即使要修改 first方法的返回值，影响的也仅仅只是Wizard本身，其他类不受影响，这显示了类的高内聚特性。

public class Wizard {

private Random rand = new Random(System.currentTimeMillis());

//第一步

private int first(){

System.out.println(“执行第一个方法…”);

return rand.nextInt(100);

}