设计模式7大原则——迪米特法则解析（含源码示例）

一、定义

迪米特法则的定义是：只与你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。

其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

二、实现方法

从迪米特法则的定义和特点可知，它强调以下两点：

1. 从依赖者的角度来说，只依赖应该依赖的对象。
2. 从被依赖者的角度说，只暴露应该暴露的方法。

所以，在运用迪米特法则时要注意以下 6 点

1. 在类的划分上，应该创建弱耦合的类。类与类之间的耦合越弱，就越有利于实现可复用的目标。
2. 在类的结构设计上，尽量降低类成员的访问权限。
3. 在类的设计上，优先考虑将一个类设置成不变类。
4. 在对其他类的引用上，将引用其他对象的次数降到最低。
5. 不暴露类的属性成员，而应该提供相应的访问器（set 和 get 方法）。
6. 谨慎使用序列化（Serializable）功能。

说这么多，下面我们举两个例子来说明一下。

三、实例1：定外卖

外卖软件大家都有吧，现在点外卖已经成了绝大部分人每天都会发生的动作，现在我们假设，有位客户点了一份披萨店的外卖，订单产生之后，披萨店接收了订单并开始为客户准备披萨，代码如下：

public class PizzaStore {
 
    public void takeOrder() {
        System.out.println("披萨店接收订单");
    }
 
    public void prepareSource() {
        System.out.println("披萨店准备披萨制作原料");
    }
 
    public void cookPizza() {
        System.out.println("披萨店烹制披萨");
    }
 
    public void packPizza() {
        System.out.println("披萨店打包披萨");
    }
 
    public void deliveryPizza() {
        System.out.println("披萨店配送披萨");
    }
}
           

public class Customer {
 
    public void orderPizza(PizzaStore pizzaStore){
        pizzaStore.takeOrder();
        pizzaStore.prepareSource();
        pizzaStore.cookPizza();
        pizzaStore.packPizza();
        pizzaStore.deliveryPizza();
    }
}
           

下面我们下一个订单，代码如下：

public static void main(String[] args){
        Customer xiaoming = new Customer();
        PizzaStore pizzaStore = new PizzaStore();
        xiaoming.orderPizza(pizzaStore);
    }
           

这样写代码貌似没有问题，但是我们可以看到当你发起订单后调用披萨店的一个整个过程太复杂，包括接收订单、准备原材料、制作披萨、打包、配送等，对于客户来说只需要：“我给你订单，你给我披萨”。可是现在客户知道了过多的披萨店的方法，这个就是违反迪米特法则的例子，我们按照迪米特法则进行修改。

public class PizzaStore {
 
    private void takeOrder() {
        System.out.println("披萨店接收订单");
    }
 
    private void prepareSource() {
        System.out.println("披萨店准备披萨制作原料");
    }
 
    private void cookPizza() {
        System.out.println("披萨店烹制披萨");
    }
 
    private void packPizza() {
        System.out.println("披萨店打包披萨");
    }
 
    private void deliveryPizza() {
        System.out.println("披萨店配送披萨");
    }
 
    public void orderPizza() {
        takeOrder();
        prepareSource();
        cookPizza();
        packPizza();
        deliveryPizza();
    }
}
           

public class Customer {
 
    public void orderPizza(PizzaStore pizzaStore){
        pizzaStore.orderPizza();
    }
 
}
           

public static void main(String[] args){
        Customer xiaoming = new Customer();
        PizzaStore pizzaStore = new PizzaStore();
        xiaoming.orderPizza(pizzaStore);
    }
           

这样改之后，客户和披萨店之间的沟通只有orderPizza()方法了，其他的方法客户根本访问不了，因为其他方法都是private属性。这样极大的减少了二者之间的沟通，这就是迪米特法则所要求的尽量减少两个实体之间的交互。我们可以进一步找一个代理类来解耦二者之间的沟通，代码如下：

//定披萨代理类
public class PizzaStoreProxy {
    private PizzaStore pizzaStore;
 
    public PizzaStoreProxy(PizzaStore pizzaStore) {
        this.pizzaStore = pizzaStore;
    }
 
    public void orderPizza() {
        pizzaStore.takeOrder();
        pizzaStore.prepareSource();
        pizzaStore.cookPizza();
        pizzaStore.packPizza();
        pizzaStore.deliveryPizza();
    }
}
//客户类
public class Customer {
 
    public void orderPizza(PizzaStoreProxy pizzaStoreProxy){
        pizzaStoreProxy.orderPizza();
    }
 
}
           

public static void main(String[] args){
        Customer xiaoming = new Customer();
        PizzaStore pizzaStore = new PizzaStore();
        PizzaStoreProxy pizzaStoreProxy = new PizzaStoreProxy(pizzaStore);
        xiaoming.orderPizza(pizzaStoreProxy);
    }
           

可以看到通过引入一个代理类，客户现在只跟披萨店代理打交道，完全不关披萨店的事，也不知道披萨店的内部实现，实现了解耦。其实这个代理类这就好比现在的美团，我们只在美团下披萨外卖订单，其他事就不需要我们管了，比如：如何做披萨、如何送披萨等等。美团在这里就起到代理的作用。

四、实例2：明星与经纪人的关系。

明星不仅全心投入艺术，还要干两件事：与粉丝的见面会，与媒体公司的业务洽谈。这些事就由经纪人负责处理。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则。

//经纪人
class Agent {
    private Star myStar;
    private Fans myFans;
    private Company myCompany;
    public void setStar(Star myStar) {
        this.myStar = myStar;
    }
    public void setFans(Fans myFans) {
        this.myFans = myFans;
    }
    public void setCompany(Company myCompany) {
        this.myCompany = myCompany;
    }
    public void meeting() {
        System.out.println(myFans.getName() + "与明星" + myStar.getName() + "见面了。");
    }
    public void business() {
        System.out.println(myCompany.getName() + "与明星" + myStar.getName() + "洽谈业务。");
    }
}
//明星
class Star {
    private String name;
    Star(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
//粉丝
class Fans {
    private String name;
    Fans(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
//媒体公司
class Company {
    private String name;
    Company(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
           

使用方法如下：

public static void main(String[] args) {
        Agent agent = new Agent();
        agent.setStar(new Star("某迪"));
        agent.setFans(new Fans("某迪小粉丝"));
        agent.setCompany(new Company("中国传媒有限公司"));
        agent.meeting();
        agent.business();
    }
           

程序的运行结果如下：

某迪小粉丝与明星某迪见面了。
中国传媒有限公司与明星某迪洽谈业务。
           

五、迪米特法则的优点和缺点

迪米特法则要求限制软件实体之间通信的宽度和深度，正确使用迪米特法则将有以下两个优点。

• 降低了类之间的耦合度，提高了模块的相对独立性。
• 由于亲合度降低，从而提高了类的可复用率和系统的扩展性。

但是，过度使用迪米特法则会使系统产生大量的中介类，从而增加系统的复杂性，使模块之间的通信效率降低。所以，在釆用迪米特法则时需要反复权衡，确保高内聚和低耦合的同时，保证系统的结构

关注我，java学习不头秃，还为每位粉丝准备了一份全面的资料福利，从面试简历模板到大厂面经汇总，从大厂内部技术资料到互联网高薪必读书单，以及Java面试核心知识点（283页）和Java面试题合集2022年最新版（485页）等等，有需要的可以点下方名片领取