#yyds干货盘点#前端迪米特法则

Posted 2022-10-27

迪米特法则(Law of Demeter )又叫做最少知识原则，也就是说，一个对象应当对其他对象尽可能少的了解。不和陌生人说话。英文简写为: LoD。

迪米特法则的目的在于降低类之间的耦合。由于每个类尽量减少对其他类的依赖，因此，很容易使得系统的功能模块功能独立，相互之间不存在（或很少有）依赖关系。

迪米特法则不希望类之间建立直接的联系。如果真的有需要建立联系，也希望能通过它的友元类来转达。因此，应用迪米特法则有可能造成的一个后果就是：系统中存在大量的中介类，这些类之所以存在完全是为了传递类之间的相互调用关系——这在一定程度上增加了系统的复杂度。

为什么要遵守迪米特法则

在面向对象编程中有一些众所周知的抽象概念，比如封装、内聚和耦合，理论上可以用来生成清晰的设计和良好的代码。虽然这些都是非常重要的概念，但它们不够实用，不能直接用于开发环境，这些概念是比较主观的，非常依赖于使用人的经验和知识。对于其他概念，如单一责任原则、开闭原则等，情况也是一样的。迪米特法则的独特之处在于它简洁而准确的定义，它允许在编写代码时直接应用，几乎自动地应用了适当的封装、低内聚和松耦合。

迪米特法则实践

那么在实践中如何做到一个对象应该对其他对象有最少的了解呢？

如果我们把一个对象看作是一个人，那么要实现“一个人应该对其他人有最少的了解”，做到两点就足够了：

• 只和直接的朋友交流；
• 减少对朋友的了解。

下面就详细说说如何做到这两点。

1. 只和直接的朋友交流

迪米特法则还有一个英文解释是：talk only to your immediate friends（只和直接的朋友交流）。

什么是朋友呢？

每个对象都必然会与其他的对象有耦合关系，两个对象之间的耦合就会成为朋友关系。那么什么又是直接的朋友呢？出现在成员变量、方法的输入输出参数中的类就是直接的朋友。迪米特法则要求只和直接的朋友通信。

注意：

只出现在方法体内部的类就不是直接的朋友，如果一个类和不是直接的朋友进行交流，就属于违反迪米特法则。

我们举一个例子说明什么是朋友，什么是直接的朋友。很简单的例子：老师让班长清点全班同学的人数。这个例子中总共有三个类：老师Teacher、班长GroupLeader和学生Student。

public interface ITeacher 
   void command(IGroupLeader groupLeader);


public class Teacher implements ITeacher
   @Override
   public void command(IGroupLeader groupLeader) 
       // 全班同学
       List<Student> allStudent = new ArrayList<>();
       allStudent.add(new Student());
       allStudent.add(new Student());
       allStudent.add(new Student());
       allStudent.add(new Student());
       allStudent.add(new Student());
       // 班长清点人数
       groupLeader.count(allStudent);

   


**
* 班长类
*/
public interface IGroupLeader 

   // 班长清点人数
   void count(List<Student> students);


/**
* 班长类
*/
public class GroupLeader implements IGroupLeader
   /**
    * 班长清点人数
    * @param students
    */
   @Override
   public void count(List<Student> students) 
       // 班长清点人数
       System.out.println("上课的学生人数是: " + students.size());
   


/**
* 学生类
*/
public interface IStudent 


/**
* 学生类
*/
public class Student implements IStudent 




/**
* 客户端
*/
public class Client 
   public static void main(String[] args) 
       // 老师类
       ITeacher wangTeacher = new Teacher();

       // 班长
       IGroupLeader zhangBanzhang = new GroupLeader();
       wangTeacher.command(zhangBanzhang);
   

复制代码

运行结果:

复制代码

在这个例子中，我们的Teacher有几个朋友？两个，一个是GroupLeader，它是Teacher的command()方法的入参；另一个是Student，因为在Teacher的command()方法体中使用了Student。

那么Teacher有几个是直接的朋友？按照直接的朋友的定义

出现在成员变量、方法的输入输出参数中的类就是直接的朋友

只有GroupLeader是Teacher的直接的朋友。

Teacher在command()方法中创建了Student的数组，和非直接的朋友Student发生了交流，所以，上述例子违反了迪米特法则。方法是类的一个行为，类竟然不知道自己的行为与其他的类产生了依赖关系，这是不允许的，严重违反了迪米特法则！

为了使上述例子符合迪米特法则，我们可以做如下修改：

public interface ITeacher 
    void command(IGroupLeader groupLeader);


public class Teacher implements ITeacher 
    @Override
    public void command(IGroupLeader groupLeader) 
        // 班长清点人数
        groupLeader.count();
    


/**
 * 班长类
 */
public interface IGroupLeader 
    // 班长清点人数
    void count();


/**
 * 班长类
 */
public class GroupLeader implements IGroupLeader 

    private List<Student> students;

    public GroupLeader(List<Student> students) 
        this.students = students;
    

    /**
     * 班长清点人数
     */
    @Override
    public void count() 
        // 班长清点人数
        System.out.println("上课的学生人数是: " + students.size());
    



/**
 * 学生类
 */
public interface IStudent 


/**
 * 学生类
 */
public class Student implements IStudent 





/**
 * 客户端
 */
public class Client 
    public static void main(String[] args) 
        // 老师类
        ITeacher wangTeacher = new Teacher();

        List<Student> allStudent = new ArrayList(10);
        allStudent.add(new Student());
        allStudent.add(new Student());
        allStudent.add(new Student());
        allStudent.add(new Student());

        // 班长
        IGroupLeader zhangBanzhang = new GroupLeader(allStudent);
        wangTeacher.command(zhangBanzhang);
    

复制代码

运行结果:

复制代码

这样修改后，每个类都只和直接的朋友交流，有效减少了类之间的耦合

2. 减少对朋友的了解

如何减少对朋友的了解？如果你的朋友是个话痨加大喇叭，那就算你不主动去问他，他也会在你面前说个不停，把他所有的经历都讲给你听。所以，要减少对朋友的了解，请换一个内敛一点的朋友吧～换作在一个类中，就是尽量减少一个类对外暴露的方法。

举一个简单的例子说明一个类暴露方法过多的情况。一个人用咖啡机煮咖啡的过程，例子中只有两个类，一个是人，一个是咖啡机。

首先是咖啡机类CoffeeMachine，咖啡机制作咖啡只需要三个方法：1.加咖啡豆；2.加水；3.制作咖啡：

/**
 * 咖啡机抽象接口
 */
public interface ICoffeeMachine 

    //加咖啡豆
    void addCoffeeBean();

    //加水
    void addWater();

    //制作咖啡
    void makeCoffee();



/**
 * 咖啡机实现类
 */
public class CoffeeMachine implements ICoffeeMachine

    //加咖啡豆
    public void addCoffeeBean() 
        System.out.println("放咖啡豆");
    

    //加水
    public void addWater() 
        System.out.println("加水");
    

    //制作咖啡
    public void makeCoffee() 
        System.out.println("制作咖啡");
    



/**
 * 人, 制作咖啡
 */
public interface IMan 
    /**
     * 制作咖啡
     */
    void makeCoffee();


/**
 * 人制作咖啡
 */
public class Man implements IMan 
    private ICoffeeMachine coffeeMachine;

    public Man(ICoffeeMachine coffeeMachine) 
        this.coffeeMachine = coffeeMachine;
    

    /**
     * 制作咖啡
     */
    public void makeCoffee() 
        coffeeMachine.addWater();
        coffeeMachine.addCoffeeBean();
        coffeeMachine.makeCoffee();
    


/**
 * 客户端
 */
public class Client 
    public static void main(String[] args) 
        ICoffeeMachine coffeeMachine = new CoffeeMachine();

        IMan man = new Man(coffeeMachine);
        man.makeCoffee();

    

复制代码

运行结果:

复制代码

在这个例子中，CoffeeMachine是Man的直接好友，但问题是Man对CoffeeMachine了解的太多了，其实人根本不关心咖啡机具体制作咖啡的过程。所以我们可以作如下优化：

优化后的咖啡机类，只暴露一个work方法，把制作咖啡的三个具体的方法addCoffeeBean、addWater、makeCoffee设为私有:

/**
 * 咖啡机抽象接口
 */
public interface ICoffeeMachine 

    //咖啡机工作
    void work();



/**
 * 咖啡机实现类
 */
public class CoffeeMachine implements ICoffeeMachine 

    //加咖啡豆
    public void addCoffeeBean() 
        System.out.println("放咖啡豆");
    

    //加水
    public void addWater() 
        System.out.println("加水");
    

    //制作咖啡
    public void makeCoffee() 
        System.out.println("制作咖啡");
    

    @Override
    public void work() 
        addCoffeeBean();
        addWater();
        makeCoffee();
    


/**
 * 人, 制作咖啡
 */
public interface IMan 
    /**
     * 制作咖啡
     */
    void makeCoffee();



/**
 * 人制作咖啡
 */
public class Man implements IMan 
    private ICoffeeMachine coffeeMachine;

    public Man(ICoffeeMachine coffeeMachine) 
        this.coffeeMachine = coffeeMachine;
    

    /**
     * 制作咖啡
     */
    public void makeCoffee() 
        coffeeMachine.work();
    


/**
 * 客户端
 */
public class Client 
    public static void main(String[] args) 
        ICoffeeMachine coffeeMachine = new CoffeeMachine();

        IMan man = new Man(coffeeMachine);
        man.makeCoffee();

    

复制代码

这样修改后，通过减少CoffeeMachine对外暴露的方法，减少Man对CoffeeMachine的了解，从而降低了它们之间的耦合。

在实践中，只要做到只和直接的朋友交流和减少对朋友的了解，就能满足迪米特法则。因此我们不难想象，迪米特法则的目的，是把我们的类变成一个个“肥宅”。“肥”在于一个类对外暴露的方法可能很少，但是它内部的实现可能非常复杂（这个解释有点牵强~）。“宅”在于它只和直接的朋友交流。在现实生活中“肥宅”是个贬义词，在日本“肥宅”已经成为社会问题。但是在程序中，一个“肥宅”的类却是优秀类的典范.