设计模式六大原则（5）：迪米特法原则

承接上文，我们继续讲道设计模式六大原则之心法----迪米特法原则。
什么是迪米特法原则？

定义：一个对象应该对其他对象保持最少的了解。
心法要诀：即一个类应该尽量不要知道其他类太多的东西，不要和陌生的类有太多接触。
核心要诀：低耦合，高内聚。
那么迪米特法原则应用场景和招式是？

问题由来：类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。
解决方案：尽量降低类与类之间的耦合。
举个栗子，通俗的讲自从我们接触编程开始，就知道了软件编程的总的原则：低耦合，高内聚。无论是面向过程编程还是面向对象编程，只有使各个模块之间的耦合尽量的低，才能提高代码的复用率。低耦合的优点不言而喻，但是怎么样编程才能做到低耦合呢？那正是迪米特法则要去完成的。

---

代码实现：

需求：有一个拖拉机生产厂，下属单位有各种拖拉机生产分厂和直属部门，现在要求打印出所有下属分厂的拖拉机型号ID。
代码一：违背迪米特法原则实现的代码：

public class Function04 {
    //测试输出类
    public static void main(String[] arg0){
        TractorManager trac = new  TractorManager();
        trac.printAllSubTractor(new SubTractorManager());
    }
}
//拖拉机总厂
class Tractor3{
    private String tractorId;

    public void setTractorId(String tractorId) {
        this.tractorId = tractorId;
    }

    public String getTractorId() {
        return tractorId;
    }
}
//总厂拖拉机信息
class TractorManager{
    public List<Tractor3> getTractorManager(){
        List<Tractor3> list = new ArrayList<Tractor3>();
        for (int i = 0 ; i <= 5 ; i++){
            Tractor3 tractor3 = new Tractor3();
            tractor3.setTractorId("总厂拖拉机型号：AT00X00"+i);
            list.add(tractor3);
        }
        return list;
    }
    //输出分厂的拖拉机型号
    public void printAllSubTractor(SubTractorManager subTractor){
        List<SubTractor> list1=subTractor.getTractorManager();
        for (SubTractor sub : list1){
            System.out.println(sub.getSubTractorId());
        }
        List<Tractor3> list2 = this.getTractorManager();
        for (Tractor3 tractor : list2) {
            System.out.println(tractor.getTractorId());
        }
    }
}
//分厂拖拉机
class SubTractor{
    private String subTractorId;

    public void setSubTractorId(String subTractorId) {
        this.subTractorId = subTractorId;
    }

    public String getSubTractorId() {
        return subTractorId;
    }
}
//分厂拖拉机信息
class SubTractorManager{
    public List<SubTractor>  getTractorManager(){
        List<SubTractor> list = new ArrayList<SubTractor>();
        for (int i = 0 ; i <= 5 ; i++){
            SubTractor subTractor = new SubTractor();
            subTractor.setSubTractorId("分厂拖拉机型号：AT00X00" + i);
            list.add(subTractor);
        }
        return list;
    }
}

运行结果：

分厂拖拉机型号：AT00X000
分厂拖拉机型号：AT00X001
分厂拖拉机型号：AT00X002
分厂拖拉机型号：AT00X003
分厂拖拉机型号：AT00X004
分厂拖拉机型号：AT00X005
总厂拖拉机型号：AT00X000
总厂拖拉机型号：AT00X001
总厂拖拉机型号：AT00X002
总厂拖拉机型号：AT00X003
总厂拖拉机型号：AT00X004
总厂拖拉机型号：AT00X005

从逻辑上讲总常只与他的分厂耦合就行了，与分厂的型号并没有任何联系，这样设计显然是增加了不必要的耦合。按照迪米特法则，应该避免类中出现这样非直接朋友关系的耦合。
代码块二：修改后的代码如下:

public class Function04 {
    //测试输出类
    public static void main(String[] arg0){
        TractorManager trac = new  TractorManager();
        trac.printAllSubTractor(new SubTractorManager());
    }
}
//拖拉机总厂
class Tractor3{
    private String tractorId;

    public void setTractorId(String tractorId) {
        this.tractorId = tractorId;
    }

    public String getTractorId() {
        return tractorId;
    }
}
//总厂拖拉机信息
class TractorManager{
    public List<Tractor3> getTractorManager(){
        List<Tractor3> list = new ArrayList<Tractor3>();
        for (int i = 0 ; i <= 5 ; i++){
            Tractor3 tractor3 = new Tractor3();
            tractor3.setTractorId("总厂拖拉机型号：AT00X00"+i);
            list.add(tractor3);
        }
        return list;
    }
    //输出分厂的拖拉机型号
    public void printAllSubTractor(SubTractorManager subTractor){
        subTractor.printAllSubTractor1();
        List<Tractor3> list2 = this.getTractorManager();
        for (Tractor3 tractor : list2) {
            System.out.println(tractor.getTractorId());
        }
    }
}
//分厂拖拉机
class SubTractor{
    private String subTractorId;

    public void setSubTractorId(String subTractorId) {
        this.subTractorId = subTractorId;
    }

    public String getSubTractorId() {
        return subTractorId;
    }
}
//分厂拖拉机信息
class SubTractorManager{
    public List<SubTractor>  getTractorManager(){
        List<SubTractor> list = new ArrayList<SubTractor>();
        for (int i = 0 ; i <= 5 ; i++){
            SubTractor subTractor = new SubTractor();
            subTractor.setSubTractorId("分厂拖拉机型号：AT00X00" + i);
            list.add(subTractor);
        }
        return list;
    }
    //输出分厂的拖拉机型号
    public void printAllSubTractor1(){
        List<SubTractor> list1=this.getTractorManager();
        for (SubTractor sub : list1){
            System.out.println(sub.getSubTractorId());
        }
    }
}

迪米特法则的初衷是降低类之间的耦合，由于每个类都减少了不必要的依赖，因此的确可以降低耦合关系。但是凡事都有度，虽然可以避免与非直接的类通信，但是要通信，必然会通过一个“中介”来发生联系，过分的使用迪米特原则，会产生大量这样的中介和传递类，导致系统复杂度变大。所以在采用迪米特法则时要反复权衡，既做到结构清晰，又要高内聚低耦合。