## 英文名称:Low of Demeter,LoD
**定义**:一个对象应该对其他对象有最少的了解。只与直接的朋友通信。
**朋友关系**：每个对象都必然会与其他对象有耦合关系，两个对象之间的耦合就称为朋友关系。
**我的理解**：迪米特法则定义的是类之间的关系要尽量低耦合，一个类中的朋友不要太多，
这样在后期代码维护或更改时需要修改的地方也就不会太多了。
**一个例子**：
体育老师要求班长清点女生的人数。
体育老师类(Teacher)：command(ClassMonitor classMonitor)方法
班长类(ClassMonitor):countGirl(List<Girl> listGirls)方法
女生类（Girl）
~~~
<span style="font-size:18px;">public class LoDTest {
public static void main(String[] args) {
new Teacher().command(new ClassMonitor());
}
}
class Teacher{
public void command(ClassMonitor classMonitor){
List<Girl> listGirls = new ArrayList<Girl>();
for(int i=0;i<10;i++){
listGirls.add(new Girl());
}
classMonitor.countGirl(listGirls);
}
}
class ClassMonitor{
public void countGirl(List<Girl> listGirls){
System.out.println("班长说：女生的数量是..."+listGirls.size());
}
}
class Girl{
}</span>
~~~
在Teacher类中，一个方法调用了两个类的实例，Teacher类依赖于ClassMonitor和Girl类。
而Teacher类中的朋友类只有ClassMonitor，Girl类是定义在方法体内的方法，因此不属于朋友类。
而迪米特法则告诉我们只与朋友类进行通信，所以这种设计方式违反了迪米特法则。
**朋友关系在java中的定义**：出现在成员变量，方法的输入输出类称为成员朋友类，而出现在方法体内部的类不属于朋友类。
**设计改进：**
去掉Teacher类中的Girl实例的创建，减少不必要的依赖关系。
使Teacher类只与直接朋友类ClassMonitor通信，而ClassMonitor类的直接朋友类是Girl类。
~~~
<span style="font-size:18px;">public class LoDTest {
public static void main(String[] args) {
List<Girl> listGirls = new ArrayList<Girl>();
for(int i=0;i<10;i++){
listGirls.add(new Girl());
}
new Teacher().command(new ClassMonitor(listGirls));
}
}
class Teacher{
public void command(ClassMonitor classMonitor){
classMonitor.countGirl();
}
}
class ClassMonitor{
List<Girl> listGirls;
public ClassMonitor(List<Girl> listGirls){
this.listGirls = listGirls;
}
public void countGirl(){
System.out.println("班长说：女生的数量是..."+listGirls.size());
}
}
class Girl{
}</span>
~~~
迪米特法则给类的低耦合提出了四个基本的要求
## 1、只和朋友类交流。
上述代码已经陈述这句话的含义，就是说尽量避免一个类中依赖于多个类的情况，一个类中的方法只与朋友类进行通信。
## 2、朋友间也是有距离的。
类似于显示生活中的情况，再亲密的朋友，也会为对方留有私人空间。
在java中的实现思想就是：类A与类B之间有依赖关系，并在方法输入或输出中创建该类的实例，那么他们属于朋友类，但是类A不可以过分操作类B的方法
**例如：**
模拟下载软件中的过程，点击下一步，完成下载软件。
**实现方式**：
1、类InstallSoftware:有一个下载软件的方法installWizard(Wizard wizard).
2、类Wizard:拥有first(),second(),third()方法。
~~~
public class LoDTest3 {
public static void main(String[] args) {
new InstallSoftware().installWizard(new Wizard());
}
}
class InstallSoftware{
public void installWizard(Wizard wizard){
int first = wizard.first();
boolean flag = false;
if(first > 50){
int second = wizard.second();
if(second>50){
int third = wizard.third();
if(third >50)
flag = wizard.over();
}
}
if(!flag)
System.out.println("下载失败...");
}
}
class Wizard{
private Random rand = new Random();
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);
}
public boolean over(){
System.out.println("下载完成...");
return true;
}
}
~~~
**设计缺陷**：这里InstallSoftware类的朋友类是Wizard类，但是InstallSoftware类太过于依赖Wizard类， 如果Wizard类有所更改，那么InstallSoftware类就会进行更改。因此我们要避免不必要的修改。
**设计改进**：尽量减少朋友类的public接口，只为InstallSoftware类提供一个服务接口，在InstallSoftware类调用Wizard类时，只需要调用他的实现方法就可以了，而没有必要替Wizard类去实现。
~~~
public class LoDTest3 {
public static void main(String[] args) {
new InstallSoftware(new Wizard()).installWizard();
}
}
class InstallSoftware{
private Wizard wizard;
public InstallSoftware(Wizard wizard){
this.wizard = wizard;
}
public void installWizard(){
wizard.installWizard();
}
}
class Wizard{
private Random rand = new Random();
private int first(){
System.out.println("执行第一个方法...");
return rand.nextInt(100);
}
private int second(){
System.out.println("执行第二个方法...");
return rand.nextInt(100);
}
private int third(){
System.out.println("执行第三个方法...");
return rand.nextInt(100);
}
private boolean over(){
System.out.println("下载完成...");
return true;
}
public void installWizard(){
int first = first();
boolean flag = false;
if(first > 50){
int second = second();
if(second>50){
int third = third();
if(third >50)
flag = over();
}
}
if(!flag)
System.out.println("下载失败...");
}
}
~~~
## 3、是自己的就是自己的
如果一个方法放在本类中，既不增加类间关系，也对本类不产生负面影响，那就放置在本类中。
## 4、谨慎使用serializable
这就话不太理解。在开发中我也很少用到过这个关键字。
我对迪米特法则的理解:迪米特法则定义的是类之间的设计的规范。也就是各自管理好自己类中的职责就行了。在开发中难免会遇到类之间的联系，那么就要严格遵守迪米特法则，对为了需求的变更有很大的帮助。
- 前言
- 6大设计原则(一)---单一职责原则
- 6大设计原则(二)---里氏替换原则
- 6大设计原则(三)---依赖倒置原则
- 6大设计模式(四)----接口隔离原则
- 6大设计原则(五)---迪米特法则
- 6大设计原则(六)---开闭原则。
- 设计模式(一)---单例模式
- 设计模式(二)---工厂方法模式
- 设计模式(三)---抽象工厂模式
- 设计模式(四)---模板方法模式
- 设计模式(五)---建造者模式
- 设计模式(六)---代理模式
- 设计模式(七)---原型模式
- 设计模式(八)---中介者模式
- 设计模式(九)---命令模式
- 设计模式(十)---责任链模式
- 设计模式(十一)---装饰模式
- 设计模式(十二)---策略模式
- 设计模式(十三)---适配器模式
- 设计模式(十四)---迭代器模式
- 设计模式(十五)---组合模式
- 设计模式(十六)---观察者模式
- 设计模式(十七)---门面模式
- 设计模式(十八)---备忘录模式
- 设计模式(十八)---访问者模式
- 设计模式(二十)---状态模式
- 设计模式(二十二)---享元模式
- 设计模式(二十三)---桥梁模式