迪米特法则

迪米特法则：在很多地方，也叫做最少知道原则，说的就是一个类对另外一个类进行操作的时候，应该对另外一个类

尽可能的少了解，降低类和类之间的耦合度，这样当其他类发生变故 ，也不会对你造成多大的影响。

该法则思想就是降低类与类之间的耦合度，降低了类之间的耦合度之后，很容易就可以使系统中的功能模块独立，相

互之间不存在（或者少有）依赖关系。

也有种说法叫：“不要和陌生人说话，而只与朋友进行交流”，也就是说：如果两个类之间如果没必要直接交互，那么

就不应当发生直接的相互调用。而是应当采用第三者类来进行转发这个调用。

当然，这个朋友，不是那么容易当的，在程序中只有以下情况的类，才能被认为是朋友类。每个对象都会与其他对象

有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖、关联、

组合、聚合等。其中，我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友，而出现在局部变量中的类

则不是直接的朋友。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部。

举个不是朋友关系的例子：

比如说，我们有个情况是：老师让班上的组长统计下组内成员有多少人。从分析上看，我们可以抽象出三种类型

的类：老师类Teacher、组长类GroupLeader、成员类Member

好，那么可能有的人就会这样搞：

/**
 * 成员类
 * 
 * @author Administrator
 *
 */
public class Member {

	private String name;

	public Member() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Member(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Member [name=" + name + "]";
	}
}

import java.util.List;

/**
 * 组长类
 * 
 * @author Administrator
 *
 */
public class GroupLeader {

	/**
	 * 给老师返回结果
	 * 
	 * @param members
	 * @return
	 */
	public int countMember(List<Member> members) {
		return members.size();
	}
}

import java.util.ArrayList;
import java.util.List;

public class Teacher {

	/**
	 * 老师命令组长统计
	 * 
	 * @param leader
	 */
	public int command(GroupLeader leader) {

		List<Member> members = new ArrayList<Member>();
		for (int i = 0; i < 5; i++) {
			Member member = new Member();
			members.add(member);
		}
		return leader.countMember(members);
	}
}

客户端调用代码为：

public class Test {

	public static void main(String[] args) {
		// 创建老师与组长对象
		Teacher teacher = new Teacher();
		GroupLeader groupLeader = new GroupLeader();

		// 老师向组长发出指令
		teacher.command(groupLeader);
	}
}

老师是让组长去统计组员人数，却没有说给组长分配组员，且组员类出现在老师方法内部，不属于朋友关系，所

以违背了迪米特法则。方法是类的一个行为，类却不知道行为中与其他类发生了依赖关系，这是不可取的。

那么正确的做法是：

import java.util.List;

/**
 * 组长类
 * 
 * @author Administrator
 *
 */
public class GroupLeader {

	private List<Member> members;

	public GroupLeader() {
		super();
		// TODO Auto-generated constructor stub
	}

	public GroupLeader(List<Member> members) {
		this.members = members;
	}

	/**
	 * 给老师返回结果
	 * 
	 * @param members
	 * @return
	 */
	public int countMember() {
		return members.size();
	}
}

public class Teacher {

	/**
	 * 老师命令组长统计
	 * 
	 * @param leader
	 */
	public int command(GroupLeader leader) {
		return leader.countMember();
	}
}

客户端修改为：

import java.util.ArrayList;
import java.util.List;

public class Test {

	public static void main(String[] args) {
		// 创建老师与组长对象
		Teacher teacher = new Teacher();

		// 这一批人，也不一定就是这样添加，这里只是模拟数据
		List<Member> members = new ArrayList<Member>();
		for (int i = 0; i < 20; i++) {
			members.add(new Member());
		}

		GroupLeader groupLeader = new GroupLeader(members);
		// 老师向组长发出指令
		teacher.command(groupLeader);
	}
}

方法尽量不引入一个类中不存在的对象，迪米特法则的初衷是降低类之间的耦合，由于每个类都减少了不必要的依

赖，因此的确可以降低耦合关系。但是凡事都有度，虽然可以避免与非直接的类通信，但是要通信，必然会通过一

个“中介”来发生联系。当然，凡事都有个度，过分的使用迪米特原则，会产生大量这样的中介和传递类，导致系统复

杂度变大。所以在采用迪米特法则时需要反复权衡，既做到结构清晰，又要高内聚低耦合。