迪米特原则

定义：

迪米特原则也叫最少知道原则，一个对象应该对其他对象保持最少的了解。

简单的说，就是如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用

迪米特法则还是在讲如何减少耦合的问题，类之间的耦合越弱，越有利于复用，一个处在弱耦合的类被修改，不会对有关系的类造成波及。也就是说，信息的隐藏促进了软件的复用。

只和朋友交流。迪米特还有一个英文解释叫做“Only talk to your immedate friends”，只和直接 的朋友通信，什么叫做直接的朋友呢？每个对象都必然会和其他对象有耦合关系，两个对象之间的耦合就 成为朋友关系，这种关系有很多比如组合、聚合、依赖等等。包括以下几类：

1. 当前对象本身（this）
2. 以参数形式传入到当前对象方法中的对象
3. 当前对象的成员对象
4. 如果当前对象的成员对象是一个集合，那么集合中的元素也都是朋友
5. 当前对象所创建的对象

举例说明：人买房子
房子类：

public class House {
    public void areas(){
        double area = 150.8;
        System.out.println("平米数："+area);
    }
    public void decorations(){
        String decoration = "豪华装修";
        System.out.println("装修："+decoration);
    }
    public void floors(){
        int floor = 16;
        System.out.println("楼层："+floor);
    }

    public void property(){
        areas();
        decorations();
        floors();
    }
}
买房人的类
```java
public class Person {
    private House house;
    public void buyHouse(){
        house.floors();
        house.decorations();
        house.areas();
        house.property();
    }
}

这里买房的人直接见到房子属性了，买房的不知道自己该注意什么怎么办？所以不符合迪米特原则，下面改进：

房子类：

public class House {
    private void areas(){
        double area = 150.8;
        System.out.println("平米数："+area);
    }
    private void decorations(){
        String decoration = "豪华装修";
        System.out.println("装修："+decoration);
    }
    private void floors(){
        int floor = 16;
        System.out.println("楼层："+floor);
    }

    public void property(){
        areas();
        decorations();
        floors();
    }
}

此时如图：

但是迪米特原则规则是减少耦合，只和朋友通讯，所以还要继续修改：
添加一个中介类：

public class Mediator {
    private House house;

    public void find(){
        house.property();
    }
}

然后人找中介买房：

public class Person {
    private Mediator mediator;
    public void buyHouse(){
        mediator.find();
    }
}

此时图解：

但是现在还有个问题，假如房子不卖了或者中介跑了怎么办？所以要加个保障，所以有了更好的方法来改造一下：
图解：

中介公司接口：

public interface IMediator {
    void find(IHouse house);
}

房源接口：

public interface IHouse {
    void property();
}

中介：

public class Mediator implements IMediator{

    @Override
    public void find(IHouse house){
        house.property();
    }
}

房子：

public class House implements IHouse{
    private void areas(){
        double area = 150.8;
        System.out.println("平米数："+area);
    }
    private void decorations(){
        String decoration = "豪华装修";
        System.out.println("装修："+decoration);
    }
    private void floors(){
        int floor = 16;
        System.out.println("楼层："+floor);
    }

    @Override
    public void property(){
        areas();
        decorations();
        floors();
    }
}

人：

public class Person {
    public void buyHouse(){
        IMediator mediator = new Mediator();
        mediator.find(new House());
    }
}

来测试一下：

public class BuyHouse {
    public static void main(String[] args) {
        Person person = new Person();
        person.buyHouse();
    }
}

结果：

这次买房就没问题了，我们可以找中介公司，公司找中介，也可以找房子，很方便，很灵活，也应用到了依赖倒置原则！