Java的开发—面向对象的7大原则之单一迪米特法则(六)

一.定义

迪米特法则，又叫最少知道原则（Least Knowledge Principle）

一个类应该保持对其他类最少的了解

也就是说：只与直接朋友交流，不和陌生人交流

朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们称之为朋友

耦合分为：依赖、关联、组合、聚合等等，我们称出现在成员变量、方法参数、方法返回值中的类为直接朋友，其他不是朋友。陌生类最好不要最为局部变量的形式出现在类的内部

二.示例

问题由来：

类与类之间的关系越紧密，他们的耦合度就越高，当一个类发生变化时，对另一个类的影响也越大

场景：去餐馆吃饭，点菜，然后厨师做菜，上菜

方式一：违反最少知道原则----我们使用硬编码，新建 服务员类 厨师类

逻辑：服务员让厨师做菜：服务员类中有个 创建厨师的方法，然后做菜

 1 /**
 2  * 厨师
 3  */
 4 public class Cook {
 5     public void cookFood(){
 6         System.out.println("厨师做菜");
 7     }
 8 }
 9
10 /**
11  * 服务员
12  */
13 public class Waiter {
14
15     private Cook cook;
16
17     public Cook createCook(){
18         if (null == cook){
19             cook = new Cook();
20         }
21         return cook;
22     }
23 }
24
25 public static void main(String[] args) {
26         System.out.println("waiter 我要点菜");
27         Waiter waiter = new Waiter();
28         System.out.println("厨师做下菜");
29         Cook cook = waiter.createCook();
30         cook.cookFood();
31     }

虽然菜做好了，可是客人会想，你干嘛把厨师也叫来，我点完菜，你拿过去给厨师做不就行了

改进：

方式二：遵循最少知道原则：客人只点好菜，然后上菜就行了，客人不需要和厨师说我要吃什么

/**
 * 厨师
 */
public class Cook {
    public void cookFood(){
        System.out.println("厨师做菜");
    }
}

/**
 * 服务员
 */
public class Waiter {

    private Cook cook;

    public void order(){
        createCook();
        cook.cookFood();
    }

    public Cook createCook(){
        if (null == cook){
            cook = new Cook();
        }
        return cook;
    }
}

public static void main(String[] args) {
        System.out.println("waiter 我要点菜");
        Waiter waiter = new Waiter();
        waiter.order();
    }

结果：客人只管点好菜，做好菜上来就行了，我不需要知道厨师是谁，不需要和厨师说做什么菜，不然要服务员干嘛

三.总结

优点：类间解偶，弱耦合，增加服用率

缺点：

1.在系统里造出大量的小方法和中介类，这些方法仅仅是传递间接的调用，与系统业务逻辑无关，增加了系统的复杂度

注意事项：

1.类的划分上应该 创建弱耦合的类

2.类的设计上，每个类应该降低成员的访问权限

3.在类的设计上，只要有可能，一个类尽可能设计成不变的类

4.对其他类的引用：一个类应该尽可能的降低对其他类的引用和依赖

5.尽量限制局部变量的有效范围，降低类的访问权限

原文地址：https://www.cnblogs.com/kukufan/p/12443371.html