设计模式（Design Pattern,DP）
设计模式的产生背景

“设计模式”这个术语最初并不是出现在软件设计中，而是被用于建筑领域的设计中。
直到 1990 年，软件工程界才开始研讨设计模式的话题。
1995年，“四人组”（Gang of Four，GoF）合作出版了《设计模式：可复用面向对象软件的基础》（Design Patterns: Elements of Reusable Object-Oriented Software）一书，在书籍中收录了 23 个设计模式，这是设 计模式领域里程碑的事件，导致了软件设计模式的突破。
直到今天，狭义的设计模式还是该书中所介绍的23种经典设计模式。

设计模式的概念

软件设计模式（Software Design Pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、 代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。也就是说，它 是解决特定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以反复使用。其目的是为了提 高代码的可重用性、代码的可读性和代码的可靠性。

1、 设计模式的六大设计原则

1.1 开闭原则：Open Closed Principle，OCP

1.1.1 开闭原则的定义

开闭原则由勃兰特·梅耶（Bertrand Meyer）提出，他在 1988 年的著作《面向对象软件构造》（Object Oriented Software Construction）中提出：软件实体应当对扩展开放，对修改关闭（Software entities should be open for extension，but closed for modification），这就是开闭原则的经典定义。

简单点说就是：一个软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化。那么什么是软件实体呢？

这里的软件实体包括以下几个部分：

• 项目中划分出的模块
• 类与接口
• 方法

一个软件产品在她的生命周期内一般都会发生变化，开闭原则视为软件实体的未来事件而制定的对现行开发设计进 行约束的一个原则。

举个例子：以书店销售书籍为例：

public interface IBook { 
  public String getName(); 
  public int getPrice();
   public String getAuthor(); 
}
public class NovelBook implements IBook{ 
  private String name;
  private int price; 
  private String author;

  public NovelBook(String name, int price, String author) {
    this.name = name; 
    this.price = price; 
    this.author = author; 
  }

  @Override 
  public String getName() { 
    return this.name;
  }

  @Override 
  public String getPrice() { 
    return this.price;
  }

  @Override 
  public String getAuthor() { 
    return this.author;
  }

public class BookStore {
   private final static ArrayList<IBook> bookList=new ArrayList();

  static {
        bookList.add(new NovelBook("红楼梦", 9900, "曹雪芹 "));   
        bookList.add(new NovelBook("侠客行", 8900, "金庸 ")); 
        bookList.add(new NovelBook("原则", 6900, "瑞·达利欧")); 
        bookList.add(new NovelBook("海贼王1", 4900, "尾田荣一郎"));
     }

public static void main(String[] args) { 
    NumberFormat format=NumberFormat.getCurrencyInstance(); 
    format.setMaximumFractionDigits(2);
     System.out.println("-------------书店卖书记录如下----------------------"); 
    for (IBook book : bookList) { 
    System.out.println("书籍名称："+book.getName()+"\t\t作者："+book.getAuthor()+"\t\t价 格："+format.format(book.getPrice()/100.0)+"元"); 
        } 
    } 
}

运行结果：

image.png

项目上线，书籍能正常销售了。但是现在双十一要到了，书店决定要来一波促销活动，70元以上的书籍9折销售， 70元以下的书籍8折销售。对该项目来说，这就是一个变化，我们该怎么应该如下变化呢？有3中解决方法：

（1）修改接口
在IBook接口里新增getOffPrice()方法，专门用于进行打折，所有的实现类都实现该方法。但这样修改的后果就 是，实现类NovelBook要修改，书店类BookStore中的main方法也要修改，同时，IBook作为接口应该是稳定且可 靠的，不应该经常发生变化，因此，该方案被否定。

（2）修改实现类
修改NovelBook类中的方法，直接在getPrice()方法中实现打折处理，这个方法可以是可以，但如果采购书籍的人 员要看价格怎么办，由于该方法已经进行了打折处理，因此采购人员看到的也是打折后的价格，会因信息不对称出 现决策失误的情况。因此，该方案也不是一个最优的方案。

（3）通过扩展实现变化
增加一个子类OffNovelBook，覆写getPrice方法，高层次的模块（也就是BookStore中static静态块中）通过 OffNovelBook类产生新的对象，完成业务变化对系统的最小开发。这样修改也少，风险也小。

image.png

image.png

运行结果：

image.png

1.1.2 开闭原则的作用

开闭原则是面向对象程序设计的终极目标，它使软件实体拥有一定的适应性和灵活性的同时具备稳定性和延续性。 具体来说，其作用如下。

1. 对软件测试的影响
软件遵守开闭原则的话，软件测试时只需要对扩展的代码进行测试就可以了，因为原有的测试代码仍然能够正常运 行。

2. 可以提高代码的可复用性
粒度越小，被复用的可能性就越大；在面向对象的程序设计中，根据原子和抽象编程可以提高代码的可复用性。

3. 可以提高软件的可维护性
遵守开闭原则的软件，其稳定性高和延续性强，从而易于扩展和维护。

1.2 单一职责原则：Single responsibility principle，SRP

这是一个备受争议的原则，跟人吵架的时候这个是屡试不爽的一个梗。

为什么会备受争议呢？怎么就能吵起来呢？主要就是对职责如何定义，什么是类的职责，以及怎么划分类的职责。

举个栗子：我们老师对学生有很多的工作要做：例如了解个人信息、每天的学习情况、记录考勤；回答学 生问题，帮助解决bug,重难点串讲；行业经验分享等。

如果将这些工作交给一位老师负责显然不合理，正确的做法是：班主任负责日常工作，技术辅导老师负责技术辅导；企业师傅负责行业经验分享等。

1.2.1 单一职责原则的定义

单一职责原则（Single Responsibility Principle，SRP）又称单一功能原则，由罗伯特·C.马丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》一书中提出的。这里的职责是指类变化的原因，单一职责原则规 定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分（There should never be more than one reason for a class to change）

该原则提出对象不应该承担太多职责，如果一个对象承担了太多的职责，至少存在以下两个缺点：

1. 一个职责的变化可能会削弱或者抑制这个类实现其他职责的能力；
2. 当客户端需要该对象的某一个职责时，不得不将其他不需要的职责全都包含进来，从而造成冗余代码或代码 的浪费

再举一个例子：

image.png

以上是符合单一职责原则的吗？说白了是一个接口只负责一件事情吗？是只有一个原因引起变化么？
好像不是哦！
其实他负责了两个内容：1、协议管理，2、数据传送。

dial()和hangup()两个方法实现的是协议管理；chat()方法负责的是数据的传送。那么协议的改变可能引起接口或者 实现类的变化；同样数据传送（电话不仅可以打电话，还能上网）的变化也可能会引起接口或实现类的变化。两个 原因都能引起变化，而两个职责直接是互不影响的，所以可以考虑拆分为两个接口。

image.png

1.2 .2 单一职责原则的优点

单一职责原则的核心就是控制类的粒度大小、将对象解耦、提高其内聚性。如果遵循单一职责原则将有以下优点。

• 降低类的复杂度。一个类只负责一项职责，其逻辑肯定要比负责多项职责简单得多。
• 提高类的可读性。复杂性降低，自然其可读性会提高。
• 提高系统的可维护性。可读性提高，那自然更容易维护了。
• 变更引起的风险降低。变更是必然的，如果单一职责原则遵守得好，当修改一个功能时，可以显著降低对其 他功能的影响

单一职责原则是最简单但又最难运用的原则，需要设计人员发现类的不同职责并将其分离，再封装到不同的类或模 块中。而发现类的多重职责需要设计人员具有较强的分析设计能力和相关重构经验。

PS：单一职责同样也适用于方法。一个方法应该尽可能做好一件事情。如果一个方法处理的事情太多，其颗粒度会 变得很粗，不利于重用。

但是原则是死的，人是活的。所以有些时候我们可以为了效率，牺牲一定的原则性。

1.3 里氏替换原则：Liskov Substitution Principle，LSP

这是一个爱恨纠葛的父子关系的故事。该原则可以理解为：子类可以替换父类。

父子类实在我们学习继承这个知识点的时候学习到的概念。我们先来回忆一下继承的优缺点：

优点：

1. 代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性；
2. 提高代码的重用性；
3. 提高代码的可扩展性，子类可形似于父类，但异于父类，保留了自己独特的个性；其实很多开源框架的扩展都 是通过继承父类实现的。
   4.提供产品或者项目的开放性。

缺点：

1. 继承是侵入性的，只要继承就必须拥有父类的所有方法和属性；
2. 降低了代码的灵活性。子类必须拥有父类的属性和方法，让子类中多了约束
3. 增加了耦合，当父类的常量、变量或者方法被修改了，需要考虑子类的修改，所以一旦父类有了变动，很可能 会造成非常糟糕的结果，要重构大量的代码。

java中使用extends关键字来实现继承，采用的是单一继承的规则，C++则采用了多重继承的规则，即一个子类可 以继承多个父类。从整体上上看，利大于弊，怎么才能更大的发挥“利”的作用呢？

解决方案就是引入里氏替换原则。什么是里氏替换原则呢？

1.3.1 里氏替换原则的定义

该原则有两个定义:

第一种：If for each object o1 of type S there is an object o2 of type T such that for all programs P defined in terms of T, the behavior of P is unchanged when o1 is substituted for o2 then S is a subtype of T.（如果每一个类型S的对象o1，都有一个类型T的对象o2，在以T定义的所有程序P中将所有的对象o2都替 换为o1，而程序P的行为没有发生变化，那么S是T的子类。）。

第二种：Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.（所有引用基类的地方必须能透明地使用其子类对象。）

第一个定义看起来有点难，其实意思就是说:在一个程序中，如果可以将一个类T的对象全部替换为另一个类S的对 象，而程序的行为没有发生变化，那么S是T的子类。

第二个定义明显要比第一个定义更容易理解，非常的清晰明确。通俗地讲，就是任何一个使用父类的地方，你都可 以把它替换成它的子类，而不会发生任何错误或异常，使用者可能根本就不需要知道是父类还是子类。但是，反过 来就不行了，有子类出现的地方，父类未必可以替换。

里氏替换原则是继承复用的基石，它为良好的继承定义了一个规范，定义中包含了4层含义：

1. 子类必须完全实现父类的方法。

我们以前做过的项目中，经常定义一个接口或者抽象类，然后编码实现，调用类则直接传入接口或者抽象 类，其实这就是已经在使用历史替换原则了

举个栗子：是不是很多人玩过CS(真人版cs或者游戏都算，没玩过也没关系，他就是一个比较火爆的第一人称 射击游戏。你就知道用到了很多枪就行了)?

image.png

image.png

在场景类中，给士兵配枪的时候可以是三种枪中的任何一个，其实士兵类可以不用知道是哪种的枪（子类） 被传入。

PS：在类中调用其他类时务必要使用父类或接口，如果不能使用父类或者接口，说明类的设计违背了里氏替 换原则

2. 子类中可以增加自己特有的方法

类都有自己的属性和方法，子类当然也不例外。除了从父类继承过来的，可以有自己独有的内容。为什么要 单独列出来，是因为里氏替换原则是不可以反过来用的。也就是子类出现的地方，父类未必可以胜任。 我们继续上面的案例：步枪下面还有几个比较知名的种类：例如AK47和AUG狙击步枪。

image.png

image.png

场景类中我们可以直接使用子类，狙击手是依赖枪支的，别说换一个型号的枪，就是同一个型号的枪都会影 响射击，所以这里直接传递子类。
如果我们直接使用父类传递进来可以吗？

image.png

会在运行的时候抛出异常，这就是我们经常说的额向下转型是不安全的。从里氏替换原则来看：子类出现的 地方，父类未必可以出现。

*3. 当子类覆盖或实现父类的方法时，方法的输入参数（方法的形参）要比父类方法的输入参数更宽松。

image.png

ps:这里子类并非重写了父类的方法，而是重载了父类的方法。因为子类和父类的方法的输入参数是不同的。 子类方法的参数Map比父类方法的参数HashMap的范围要大，所以当参数输入为HashMap类型时，只会执行父类的方 法，不会执行父类的重载方法。这符合里氏替换原则。

4. 当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

image.png

1.3.2 里氏替换原则的作用

里氏替换原则的主要作用如下。

1. 里氏替换原则是实现开闭原则的重要方式之一。
2. 它克服了继承中重写父类造成的可复用性变差的缺点。
3. 它是动作正确性的保证。即类的扩展不会给已有的系统引入新的错误，降低了代码出错的可能性。

里氏替换原则通俗来讲就是：子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类 时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是 运用多态比较频繁时，程序运行出错的概率会非常大。

如果程序违背了里氏替换原则，则继承类的对象在基类出现的地方会出现运行错误。这时其修正方法是：取消原来 的继承关系，重新设计它们之间的关系。

1.4 依赖倒置原则：Dependence Inversion Principle，DIP

1.4.1 依赖倒置原则的定义

依赖倒置原则的原始定义为:High level modules shouldnot depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details. Details should depend upon abstractions。

其实里面包含了三层含义：

• 高层模块不应该依赖低层模块，两者都应该依赖其抽象；
• 抽象不应该依赖细节，
• 细节应该依赖抽象。

核心思想：要面向接口编程，不要面向实现编程。

依赖倒置原则是实现开闭原则的重要途径之一，它降低了客户与实现模块之间的耦合。

由于在软件设计中，细节具有多变性，而抽象层则相对稳定，因此以抽象为基础搭建起来的架构要比以细节为基础 搭建起来的架构要稳定得多。这里的抽象指的是接口或者抽象类，而细节是指具体的实现类。

使用接口或者抽象类的目的是制定好规范和契约，而不去涉及任何具体的操作，把展现细节的任务交给它们的实现 类去完成。

1.4.2 依赖倒置原则的作用

• 依赖倒置原则可以降低类间的耦合性。
• 依赖倒置原则可以提高系统的稳定性。
• 依赖倒置原则可以减少并行开发引起的风险。
• 依赖倒置原则可以提高代码的可读性和可维护性

我们来举个栗子说明上面的这些作用。（我们反向证明一下）

现在汽车越来越便宜，所有人们出行的时候开车出行的越来越多。在此场景下，有了汽车，开车的人就是司机。 我们使用程序来描述一下：

image.png

司机开奔驰车这个项目没有问题了。业务需求变更的时候更能发觉我们的设计或程序是否是松耦合。所以现在我们 填个需求：司机不仅能开奔驰车，还能开宝马车，该怎么实现呢？

不管怎么实现，先把宝马车产出出来：

image.png

车有了，可是我们的司机james竟然没办法开动，james没有开动宝马的方法啊！拿了驾照只能开奔驰也不太合理 吧！现实世界都不这样，更何况程序还是对现实世界的抽象呢。

很显然，我们的设计不合理：司机类和奔驰车类之间是紧耦合的关系，结果就是系统的可维护性降低、可阅读性降 低，两个相似的类要阅读两个类；这里增加了一个车类就需要修改司机类，让程序变得不稳定。这样我们就证明了 不使用依赖导致原则就没有前两个好处。

继续证明“减少并行开发的风险”，什么是并行开发风险？本来只是一段程序的错误或者异常，逐步波及一个功能、 一个模块，甚至最后毁掉整个项目。为什么并行开发有这也的风险？假如一个团队有20个人，各人负责不同的功能 模块，A负责汽车类，B负责司机类......在A未完成的情况下，B不能完全的编写代码，因为缺少汽车类编译器编译根 本通不过，就更不用说单元测试了！在这种不使用依赖倒置原则的情况下，所有的开发都是“单线程”的，只能是A 做完B再做......在早期的小型项目中还可以，但在现在的中大型项目中就不合适了，需要团队人员同时并行开发，所 以这个时候依赖原则的作用就体现出来了。因为根据上面的案例已经说明不使用依赖倒置原则就会增加类直接的耦 合性，降低系统的稳定性、可读性和维护性，增加了并行开发的风险。

咱们将上面的案例引入依赖倒置原则：

image.png

image.png

james和benz表明的类型都是接口，是抽象的，虽然在实例化对象的时候调用了低层模块，但是后续所有操作中， james都是以IDriver类型进行操作，屏蔽了细节对抽象的影响。

如果我们此时再新增一个低层模块，只修改业务场景类，也就是高层模块，对其它低层模块不需要做任何修改，业 务依然可以运行，把变更引起的风险扩散降到最低。

依赖倒置对并行开发的影响。只要定义好了接口，即使负责Car开发的程序员工作滞后，我们依然可用进行测试。 引入了JMock工具，根据抽象虚拟一个对象进行测试（不了解该测试工具也没关系，以后有机会再了解）。

image.png

1.4.3 依赖倒置原则的实现方法

依赖倒置原则的目的是通过要面向接口的编程来降低类间的耦合性，所以我们在实际编程中只要遵循以下4点，就 能在项目中满足这个规则。

1. 每个类尽量提供接口或抽象类，或者两者都具备。
2. 变量的声明类型尽量是接口或者是抽象类。
3. 任何类都不应该从具体类派生。
4. 尽量不要覆写基类的方法
5. 使用继承时结合里氏替换原则。

1.5 接口隔离原则:Interface Segregation Principle，ISP

1.5.1 接口隔离原则的定义

接口隔离原则要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方 法。

2002 年罗伯特·C.马丁给“接口隔离原则”的定义是：客户端不应该被迫依赖于它不使用的方法（Clients should not be forced to depend on methods they do not use）。该原则还有另外一个定义：一个类对另一个类的依赖应该 建立在最小的接口上（The dependency of one class to another one should depend on the smallest possible interface）。

以上两个定义的含义是：要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它 的类去调用。

接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性，体现了封装的思想，但两者是不同 的:

• 单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。
• 单一职责原则主要是约束类，它针对的是程序中的实现和细节；接口隔离原则主要约束接口，主要针对抽象 和程序整体框架的构建。

我们举个栗子说明一下：现在有个特别流行的词:小姐姐。我觉得这是对美女的别称。什么是美女呢？一般来说：首 先长得好看，其次身材窈窕，最后还有气质。我们按照这三种要求去寻求美女(也过一把星探的瘾)。

image.png

image.png

我们的审美观点一直在改变，美女的定义也在变化。例如看到一个女孩：身材面容一般，但是气质特别好，我们也 会把她成为美女，于是产生了气质美女，但是我们的接口中却定义了美女都必须具备三个条件，按照这个标准，气 质美女就不是美女了，怎么办呢？

重新扩展一个美女类，只实现气质方法，其他两个方法置空就好啦！可是星探类AbstractSearcher依赖的是 IPettyGirl接口，它有3个方法，星探的方法是不是要修改？

分析到这里，我们发现其实是IPettyGirl的设计有缺陷，过于庞大，容纳了一些可变的因素，根据接口隔离的原 则，星探AbstractSearcher应该依赖具有部分特质的女孩子，而我们却把这些都放到了一个接口中。

找到问题原因，接下来就解决问题：我们把臃肿的接口分为两个：一个面容身材好接口，一个气质好接口。

image.png

把一个臃肿的接口变为两个独立的接口所依赖的原则就是接口隔离原则。

1.5.2 接口隔离原则的优点

接口隔离原则是为了约束接口、降低类对接口的依赖性，遵循接口隔离原则有以下 5 个优点。

1. 将臃肿庞大的接口分解为多个粒度小的接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。
2. 接口隔离提高了系统的内聚性，减少了对外交互，降低了系统的耦合性。
3. 如果接口的粒度大小定义合理，能够保证系统的稳定性；但是，如果定义过小，则会造成接口数量过多，使 设计复杂化；如果定义太大，灵活性降低，无法提供定制服务，给整体项目带来无法预料的风险。
4. 使用多个专门的接口还能够体现对象的层次，因为可以通过接口的继承，实现对总接口的定义。
5. 能减少项目工程中的代码冗余。过大的大接口里面通常放置许多不用的方法，当实现这个接口的时候，被迫 设计冗余的代码。

1.5.3 接口隔离原则的实现方法

在具体应用接口隔离原则时，应该根据以下几个规则来衡量。

• 接口尽量小，但是要有限度。一个接口只服务于一个子模块或业务逻辑。
• 为依赖接口的类定制服务。只提供调用者需要的方法，屏蔽不需要的方法。
• 了解环境，拒绝盲从。每个项目或产品都有选定的环境因素，环境不同，接口拆分的标准就不同深入了解业 务逻辑。
• 提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情

1.6 迪米特法则：Law of Demeter，LoD

1.6.1 迪米特法则的定义

迪米特法则（Law of Demeter，LoD）又叫作最少知识原则（Least Knowledge Principle，LKP)，产生于 1987 年 美国东北大学（Northeastern University）的一个名为迪米特（Demeter）的研究项目，由伊恩·荷兰（Ian Holland）提出，它要求一个对象应该对其他对象有最少的了解。通俗的说，一个类应该对自己需要耦合或调用的 类知道的最少，被耦合或调用的类的内部是如何复杂都与我无关，我就知道你提供的public方法就好。

迪米特法则还是在讲如何减少耦合的问题，类之间的耦合越弱，越有利于复用，一个处在弱耦合的类被修改，不会 对有关系的类造成波及。也就是说，信息的隐藏促进了软件的复用。

迪米特法则还有一个定义是：只与你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以 通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

什么叫做直接的朋友呢？每个对象都必然会和其他对象有耦合关系，两个对象之间的耦合就 成为朋友关系，这种关 系有很多比如组合、聚合、依赖等等。包括以下几类：

1. 当前对象本身（this）
2. 当前对象的方法参数（以参数形式传入到当前对象方法中的对象）
3. 当前对象的成员对象
4. 如果当前对象的成员对象是一个集合，那么集合中的元素也都是朋友
5. 当前对象所创建的对象

1.6.2 迪米特法则的优点

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

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

1.6.3 迪米特法则的实现方法

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

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

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

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

举个栗子：明星平时档期都很满，例如拍电影、演出、粉丝见面会等等，那么他们的这些日程是怎么来的呢？一般 都是由经纪人负责处理。这里的经纪人是明星的朋友，而见面会上的粉丝和拍电影或举办演出的媒体公司是陌生 人，所以适合使用迪米特法则.

image.png

image.png