「设计模式」面向对象7大设计原则—迪米特法则

Posted 2022-12-11 程序编织梦想

迪米特法则的定义是：只与你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。
其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。
迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

迪米特法则的实现方法

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

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

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

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

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

实例一：定外卖

小明在app上点外卖，他选择了一家披萨店，并向披萨店下了一份订单，披萨店接收了订单并开始为小明准备披萨，代码如下：

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);
    

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

实例二：明星与经纪人的关系

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

//经纪人
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知识！