java设计模式书籍推荐(java设计模式的书籍推荐) 收藏 0

B站最全最详细的java设计模式！还不赶紧收藏

一 、设计模式概述

1.什么是设计模式

设计模式是一套被多数人知晓、经过分类编目的、反复使用的优秀代码设计经验的总结。

注意，具体到某个设计模式，它只是特定环境下特定问题的处理方式。

单词本身起源于建筑工程领域。1995年GoF出版《Deslgn Pattems:Elements of Reusable Object-Oriented Software 》,第一次将设计模式提升到理论高度，并将之规范化。该书提出了23种基本设计模式。时至今日，在可复用面向对象软件的发展过程中，新的设计模式仍然不断出现

2.设计模式的作用

1. 重用设计和代码

重用设计比重用代码更有意义，自动带来代码重用

2.提高扩展性

大量使用面向接口编程，预留扩展插槽，新的功能特性很容易加入到系统中来

3.提高灵活性

大量使用组合而不是继承来提高灵活性，可以允许代码修改平稳发生，对一处的修改不会波及到很多其他模块

4.提高开发效率

正确使用设计模式，可以节省大量的时间

3.设计模式分类

分类1：按照设计模式解决的问题可以分为创建型设计模式、结构性设计模式、行为型设计模式。

创建型设计模式：对象实例化的模式，用于解耦对象的实例化过程。

结构型模式：把类或对象结合在一起形成一个更大的结构。

行为型模式：类和对象如何交互，及划分责任和算法

分类2：根据是处理对象间关系还是父子类间关系，分为类设计模式和对象设计模式

类设计模式：用于处理类和子类之间的关系。通过继承建立关系是静态的在编译时就已经确定。因为从某种意义上说，几乎所有模式都是使用继承机制，因此此处的“类模式”是指集中处理类间关系的模式，只是很少部分模式属于此类。

对象设计模式:用于处理对象间的关系。这些关系具有动态性，在运行期间是可变化的。

经典书单 ，最受程序员推荐的Java书籍，值得阅读

点击上方☝，轻松关注！及时获取有趣有料的技术文章

书籍绝对是一种很好的学习方式，将它们和文章、教程和视频结合使用，你一定会有一个事半功倍的效果

Java是最重要的编程语言之一，关于Java编程的书籍并不少见，不仅有关于各种Java概念概述，还有更深入的具体到各个Java主题内容的书籍。

近日，hackr.io编程社区，评选出11本优秀的Java书籍来帮助读者学习Java。

1、《Java核心技术·卷 I》

这一本Java参考书，它详细解释了Java核心的各种特性，包括异常处理、接口和lambda表达式。这本书的主要亮点在于内容详实，语言简洁，示例讲解详细

Java核心技术·卷 I的最新版本（第11版本）全面更新，涵盖了Java SE 9、10和11。这本书帮助Java程序员开发编写高度可读和可维护代码的能力，被认为是面向高级程序员的经典教程和参考书。

2、《Effective Java》

本书也是每个Java程序员必读的一本书，《Effective java》可以作为其他Java书籍的一个很好的补充，这本书提供了90个条目，每个条目中的规则都反映了最有经验的优秀程序员在实践中常用的一些有益的做法。

《Effective Java》将所有提到的最佳实践分为11章，例如并发性、泛型和方法，从而使读者更容易掌握所有的这些内容。

本书是Joshua Bloch编写的，他也是许多关键Java类和API的作者。包括Java.lang和Java Collection 框架。该书的最新版本内容主要围绕Java 7、8和9构建的。

3、《Java: A Beginner’s Guide》

不要被这本书的标题误导了，事实上，它是Java最全面的书籍之一。任何编程水平的人都能从这本指南中学到东西，里面涵盖了与 Core Java相关的所有概念本书的最新版经过全面修订，还包括Java 11 SE。除此之外，为了让读者在阅读后能有个自我检测，本书的每章末尾都会提供几个练习题。

4、《Java: The Complete Reference》

这是一本超过1000页的大小适中的Java参考书。它包含读者需要掌握的Java的每个方面。除了检查Java API库的重要部分之外，本书还包括基本的编程原则，Java语言语法和关键字。本书还有许多恰到好处的示例帮助你更好地学习Java

5、《Head First Java》

本书最重要的卖点在于它的简单，以及把Java编程概念形象具体化，书中几乎涵盖所有OOPS概念，并以非常有趣的方式解释它们。

尽管一些读者认为这是一本过时的书，因为它只涵盖Java 5.0以下的内容，但是Head First Java仍然可以在许多Java老手的书架上找到。因此，把它当成是Java开发人员的必备书籍也不为过。

Head First Java所涵盖的一些值得注意的主题包括常见的OO错误、线程、网络与分布式程序等项目。此外，这本书还涵盖了42个难解的试题，来帮助你更好地理解Java。

6、《Java并发编程实战》

本书深入浅出地介绍了Java线程和并发，是最佳Java编程书籍之一。不要被本书对Java 5.0的介绍所误解了，因为它对于任何Java开发人员来说仍然是相关且必不可少的。

本书唯一问题是一些部分最初可能很难理解。但是，你也应该知道并发和多线程本身就是很难的主题。但是当你读完本书的时候，你会发现一切都是值得的。

7、《测试驱动开发的艺术》

这是一本学习如何编写优秀自动化测试程序的好书。对于那些优先考虑代码质量以及编写单元、集成和自动化测试技巧的Java开发人员来说，这是一本必备的书。

书中提供了大量实例来解释TDD。此外，本书还介绍了验收测试驱动开发(ATDD)、Fit框架和测试Java EE组件(jsp、servlet和Spring控制器)。

8、《深入浅出面向对象分析与设计》

Head First是用Java编程语言编写的最好的书籍系列之一，它和《Head First Java》、《深入浅出设计模式》被并成为Head First Java三部曲。

本书详细介绍了面向对象编程和设计中所使用的不同技术，诸如接口编码以及如何封装更改等。《深入浅出面向对象分析与设计》是一本能够帮你写出更好的Java代码的好书。

9、《Java性能权威指南》

垃圾收集，JVM和性能调优是Java编程语言最大的有点。本书用一个简单而有效的方式涵盖了所有这三大Java主题，帮助你最大化Java线程和同步性能特性，改进Java驱动的数据库应用程序性能，解决Java EE和Java SE API中的性能问题等等。

10、《Head First 设计模式》

想要编写出完美的Java应用程序，掌握OOP和设计模式是必不可少的，书中每章都介绍了几个设计模式，提供了许多关于Java常见问题的解决方案，诸如为什么组合比继承好，本书的最新版本针对Java 8进行了更新，与其他书籍不同的是本书旨在用一些丰富的场景让原本枯燥的学习变得有趣。

11、《代码整洁之道》

《代码整洁之道》也是一本经典的Java编程书籍，本书作者给出了一系列行之有效的整洁代码操作实践。这些实践在本书中体现为一条条规则（或称“启示”），并辅以来自现实项目的正、反两面的范例。只要遵循这些规则，就能编写出干净的代码，从而有效提升代码质量。

其他

• 《Core Java 》豆瓣评分 8.7
• 《Extreme Java – Concurrency Performance for Java 8》
• 《Java How to Program》豆瓣评分 8.0
• 《Java 8实战 》豆瓣评分 9.2
• 《Java in a Nutshell》豆瓣评分 9.3
• 《爱上Python》豆瓣评分 7.2
• 《Java编程规范》豆瓣评分 8.5
• 《像计算机科学家一样思考Python (第2版)》 豆瓣评分 8.6
• 《21天学通Java》
• 《 Spring实战（第4版）》豆瓣评分 8.3

私信回复 书籍，获取电子版书籍！

java的设计模式汇总

java的设计模式大体上分为三大类：

创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，

原型模式。

结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模

式，组合模式，享元模式。

行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、

责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解

释器模式。

设计模式遵循的原则有6个：

1、开闭原则（Open Close Principle）

对扩展开放，对修改关闭。

2、里氏代换原则（Liskov Substitution Principle）

只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真

正被复用，而衍生类也能够在基类的基础上增加新的行为。

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

使用多个隔离的借口来降低耦合度。

5、迪米特法则（最少知道原则）（Demeter Principle）

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相

对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。继承实际上破坏了类

的封装性，超类的方法可能会被子类修改。

1.单例模式：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这

个实例。

（1）懒汉式

1 public class Singleton {

23 /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加

载 */

4 private static Singleton instance = null;

5

6 /* 私有构造方法，防止被实例化 */

7 private Singleton() {

8 }

9

10 /* 1:懒汉式，静态工程方法，创建实例 */

11 public static Singleton getInstance() {

12 if (instance == null) {

13 instance = new Singleton();

14 }

15 return instance;

16 }

17 }

（2）饿汉式

1 public class Singleton {

2

3 /* 持有私有静态实例，防止被引用 */

4 private static Singleton instance = new Singleton();

5

6 /* 私有构造方法，防止被实例化 */

7 private Singleton() {

8 }

9

10 /* 1:懒汉式，静态工程方法，创建实例 */

11 public static Singleton getInstance() {

12 return instance;

13 }

14 }

使用场景：

1.要求生成唯一序列号的环境；2.在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数

器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并

确保是线程安全的；

3.创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；

4.需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式

（当然，也可以直接声明为static的方式）。

2.工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂

方法使一个类的实例化延迟到其子类。

接口

1 public interface Fruit {

2 public void print();

3 }

4 2个实现类

5

6 public class Apple implements Fruit{

7

8 @Override

9 public void print() {

10 System.out.println(\”我是一个苹果\”);

11 }

12

13 }

14 public class Orange implements Fruit{

15

16 @Override

17 public void print() {

18 System.out.println(\”我是一个橘子\”);

19 }

20

21 }

工厂类1 public class FruitFactory {

2 public Fruit produce(String type){

3 if(type.equals(\”apple\”)){

4 return new Apple();

5 }else if(type.equals(\”orange\”)){

6 return new Orange();

7 }else{

8 System.out.println(\”请输入正确的类型!\”);

9 return null;

10 }

11 }

12 }

使用场景：jdbc连接数据库，硬件访问，降低对象的产生和销毁

3.抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无须指

定它们的具体类。

相对于工厂模式，我们可以新增产品类（只需要实现产品接口），只需要同时新

增一个工厂类，客户端就可以轻松调用新产品的代码。

1 interface food{}

2 class A implements food{}

3 class B implements food{}

4 interface produce{ food get();}

5 class FactoryForA implements produce{

6 @Override

7 public food get() {

8 return new A();

9 }

10 }

11 class FactoryForB implements produce{

12 @Override

13 public food get() {

14 return new B();

15 }

16 }17 public class AbstractFactory {

18 public void ClientCode(String name){

19 food x= new FactoryForA().get();

20 x = new FactoryForB().get();

21 }

22 }

使用场景：一个对象族（或是一组没有任何关系的对象）都有相同的约束。

涉及不同操作系统的时候，都可以考虑使用抽象工厂模式

4.建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可

以创建不同的表示。

1 public class Build {

2 static class Student{

3 String name = null ;

4 int number = ‐1 ;

5 String sex = null ;

6 public Student(Builder builder)

7 {

8 this.name=builder.name;

9 this.number=builder.number;

10 this.sex=builder.sex;

11 }

12 static class Builder{

13 String name = null ;

14 int number = ‐1 ;

15 String sex = null ;

16 public Builder setName(String name){

17 this.name=name;

18 return this;

19 }

20 public Builder setNumber(int number){

21 this.number=number;

22 return this;

23 }

24 public Builder setSex(String sex){25 this.sex=sex;

26 return this;

27 }

28 public Student build(){

29 return new Student(this);

30 }

31

32 }

33 }

34 public static void main(String[] args) {

35 Student A=new Student.Builder().setName(\”张

三\”).setNumber(1).build();

36 Student B=new Student.Builder().setSex(\”男\”).setName(\”李

四\”).build();

37 System.out.println(A.name+\” \”+A.number+\” \”+A.sex);

38 System.out.println(B.name+\” \”+B.number+\” \”+B.sex);

39 }

40 }

使用场景：

1. 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模

式。

2.多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同

时，则可以使用该模式。

3.产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候

使用建造者模式非常合适。

5.原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的

对象。

1 public class Prototype implements Cloneable{

2 private String name;

3 public String getName() {

4 return name;

5 }

6 public void setName(String name) {

7 this.name = name;8 }

9 @Override

10 protected Object clone() {

11 try {

12 return super.clone();

13 } catch (CloneNotSupportedException e) {

14 e.printStackTrace();

15 }finally {

16 return null;

17 }

18 }

19 public static void main ( String[] args){

20 Prototype pro = new Prototype();

21 Prototype pro1 = (Prototype)pro.clone();

22 }

23 }

原型模式实际上就是实现Cloneable接口，重写clone（）方法。

使用原型模式的优点：

1.性能优良

原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是

要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。

2.逃避构造函数的约束

这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的（参见

13.4节）。

使用场景：

1.资源优化场景

类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。

2.性能和安全要求的场景

通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模

式。

3. 一个对象多个修改者的场景一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可

以考虑使用原型模式拷贝多个对象供调用者使用。

浅拷贝和深拷贝：

浅拷贝：Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用

对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝，

其他的原始类型比如int、long、char、string（当做是原始类型）等都会被拷

贝。

注意： 使用原型模式时，引用的成员变量必须满足两个条件才不会被拷贝：一

是类的成员变量，而不是方法内变量；二是必须是一个可变的引用对象，而不是

一个原始类型或不可变对象。

深拷贝：对私有的类变量进行独立的拷贝

如：this.arrayList = (ArrayList)this.arrayList.clone();

6.适配器模式：将一个类的接口变换成客户端所期待的另一种接口，从而使原本

因接口不匹配而无法在一起工作的两个类能够在一起工作。

主要可分为3种：

1.类适配：创建新类，继承源类，并实现新接口，例如

1 class adapter extends oldClass implements newFunc{}

2.对象适配：创建新类持源类的实例，并实现新接口，例如

1 class adapter implements newFunc { private oldClass oldInstance

;}

3.接口适配：创建新的抽象类实现旧接口方法。例如

1 abstract class adapter implements oldClassFunc { void

newFunc();}

使用场景：

你有动机修改一个已经投产中的接口时，适配器模式可能是最适合你的模式。比

如系统扩展了，需要使用一个已有或新建立的类，但这个类又不符合系统的接

口，怎么办？使用适配器模式，这也是我们例子中提到的。

7.装饰器模式：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰

器模式相比生成子类更为灵活1 interface Source{ void method();}

2 public class Decorator implements Source{

3 private Source source ;

4 public void decotate1(){

5 System.out.println(\”decorate\”);

6 }

7 @Override

8 public void method() {

9 decotate1();

10 source.method();

11 }

12 }

使用场景：

1. 需要扩展一个类的功能，或给一个类增加附加功能。

2. 需要动态地给一个对象增加功能，这些功能可以再动态地撤销。

3. 需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式。

8.代理模式：为其他对象提供一种代理以控制对这个对象的访问。

1 interface Source{

2 void method();

3 }

4 class OldClass implements Source{

5 @Override

6 public void method() {

7 }

8 }

9 class Proxy implements Source{

10 private Source source = new OldClass();

11 void doSomething(){}

12 @Override

13 public void method() {

14 new Class1().Func1();

15 source.method();

16 new Class2().Func2();

17 doSomething();18 }

19 }

9.中介者模式：用一个中介对象封装一系列的对象交互，中介者使各对象不需要

显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

1 public abstract class Mediator {

2 //定义同事类

3 protected ConcreteColleague1 c1;

4 protected ConcreteColleague2 c2;

5 //通过getter/setter方法把同事类注入进来

6 public ConcreteColleague1 getC1() {

7 return c1;

8 }

9 public void setC1(ConcreteColleague1 c1) {

10 this.c1 = c1;

11 }

12 public ConcreteColleague2 getC2() {

13 return c2;

14 }

15 public void setC2(ConcreteColleague2 c2) {

16 this.c2 = c2;

17 }

18 //中介者模式的业务逻辑

19 public abstract void doSomething1();

20 public abstract void doSomething2();

21 }

使用场景：

中介者模式适用于多个对象之间紧密耦合的情况，紧密耦合的标准是：在类图中

出现了蜘蛛网状结构，即每个类都与其他的类有直接的联系。

10.命令模式：将一个请求封装成一个对象，从而让你使用不同的请求把客户端

参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

Receiver接受者角色：该角色就是干活的角色，命令传递到这里是应该被执行的Command命令角色：需要执行的所有命令都在这里声明

Invoker调用者角色：接收到命令，并执行命令

1 //通用Receiver类

2 public abstract class Receiver {

3 public abstract void doSomething();

4 }

5 //具体Receiver类

6 public class ConcreteReciver1 extends Receiver{

7 //每个接收者都必须处理一定的业务逻辑

8 public void doSomething(){ }

9 }

10 public class ConcreteReciver2 extends Receiver{

11 //每个接收者都必须处理一定的业务逻辑

12 public void doSomething(){ }

13 }

14 //抽象Command类

15 public abstract class Command {

16 public abstract void execute();

17 }

18 //具体的Command类

19 public class ConcreteCommand1 extends Command {

20 //对哪个Receiver类进行命令处理

21 private Receiver receiver;

22 //构造函数传递接收者

23 public ConcreteCommand1(Receiver _receiver){

24 this.receiver = _receiver;

25 }

26 //必须实现一个命令

27 public void execute() {

28 //业务处理

29 this.receiver.doSomething();

30 }

31 }

32 public class ConcreteCommand2 extends Command {

33 //哪个Receiver类进行命令处理34 private Receiver receiver;

35 //构造函数传递接收者

36 public ConcreteCommand2(Receiver _receiver){

37 this.receiver = _receiver;

38 }

39 //必须实现一个命令

40 public void execute() {

41 //业务处理

42 this.receiver.doSomething();

43 }

44 }

45 //调用者Invoker类

46 public class Invoker {

47 private Command command;

48

49 public void setCommand(Command _command){

50 this.command = _command;

51 }

52

53 public void action() {

54 this.command.execute();

55 }

56 }

57 //场景类

58 public class Client {

59 public static void main(String[] args){

60 Invoker invoker = new Invoker();

61 Receiver receiver = new ConcreteReceiver1();

62

63 Command command = new ConcreteCommand1(receiver);

64 invoker.setCommand(command);

65 invoker.action();

66 }

67 }

使用场景：认为是命令的地方就可以采用命令模式，例如，在GUI开发中，一个按钮的点击

是一个命令，可以采用命令模式；模拟DOS命令的时候，当然也要采用命令模

式；触发－反馈机制的处理等。

11.责任链模式：使多个对象都有机会处理请求，从而避免了请求的发送者和接

受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到

有对象处理它为止。

1 public abstract class Handler {

2 private Handler nextHandler;

3 //每个处理者都必须对请求做出处理

4 public final Response handleMessage(Request request){

5 Response response = null;

6 //判断是否是自己的处理级别

7 if(this.getHandlerLevel().equals(request.getRequest

Level())){

8 response = this.echo(request);

9 }else{ //不属于自己的处理级别

10 //判断是否有下一个处理者

11 if(this.nextHandler != null){

12 response = this.nextHandler.handleM

essage(request);

13 }else{

14 //没有适当的处理者，业务自行处理

15 }

16 }

17 return response;

18 }

19 //设置下一个处理者是谁

20 public void setNext(Handler _handler){

21 this.nextHandler = _handler;

22 }

23 //每个处理者都有一个处理级别

24 protected abstract Level getHandlerLevel();

25 //每个处理者都必须实现处理任务

26 protected abstract Response echo(Request request);

27 }12.策略模式：定义一组算法，将每个算法都封装起来，并且使它们之间可以互

换。

使用场景：

1. 多个类只有在算法或行为上稍有不同的场景。

2. 算法需要自由切换的场景。

3. 需要屏蔽算法规则的场景。

13.迭代器模式：它提供一种方法访问一个容器对象中各个元素，而又不需暴露

该对象的内部细节。

迭代器模式已经被淘汰，java中已经把迭代器运用到各个聚集类（collection）

中了，使用java自带的迭代器就已经满足我们的需求了。

14.组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用

户对单个对象和组合对象的使用具有一致性。

1 public class Composite extends Component {

2 //构件容器

3 private ArrayList componentArrayList = new ArrayList();

4 //增加一个叶子构件或树枝构件

5 public void add(Component component){

6 this.componentArrayList.add(component);

7 }

8 //删除一个叶子构件或树枝构件

9 public void remove(Component component){

10 this.componentArrayList.remove(component);

11 }

12 //获得分支下的所有叶子构件和树枝构件

13 public ArrayList getChildren(){

14 return this.componentArrayList;

15 }

16 }

使用场景：

1. 维护和展示部分-整体关系的场景，如树形菜单、文件和文件夹管理。

2. 从一个整体中能够独立出部分模块或功能的场景。15.观察者模式：定义对象间一种一对多的依赖关系，使得每当一个对象改变状

态，则所有依赖于它的对象都会得到通知并被自动更新。

1 public abstract class Subject {

2 //定义一个观察者数组

3 private Vector obsVector = new Vector();

4 //增加一个观察者

5 public void addObserver(Observer o){

6 this.obsVector.add(o);

7 }

8 //删除一个观察者

9 public void delObserver(Observer o){

10 this.obsVector.remove(o);

11 }

12 //通知所有观察者

13 public void notifyObservers(){

14 for(Observer o:this.obsVector){

15 o.update();

16 }

17 }

18 }

使用场景：

1. 关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合”关

系。

2. 事件多级触发场景。

3. 跨系统的消息交换场景，如消息队列的处理机制

16.门面模式：要求一个子系统的外部与其内部的通信必须通过一个统一的对象

进行。门面模式提供一个高层次的接口，使得子系统更易于使用。

1 public class Facade {

2 private subSystem1 subSystem1 = new subSystem1();

3 private subSystem2 subSystem2 = new subSystem2();

4 private subSystem3 subSystem3 = new subSystem3();

5

6 public void startSystem(){

7 subSystem1.start();8 subSystem2.start();

9 subSystem3.start();

10 }

11

12 public void stopSystem(){

13 subSystem1.stop();

14 subSystem2.stop();

15 subSystem3.stop();

16 }

17 }

使用场景：

1. 为一个复杂的模块或子系统提供一个供外界访问的接口

2. 子系统相对独立——外界对子系统的访问只要黑箱操作即可

3. 预防低水平人员带来的风险扩散

17.备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该

对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

1 public class Originator {

2 private String state;

3 /**

4 * 工厂方法，返回一个新的备忘录对象

5 */

6 public Memento createMemento(){

7 return new Memento(state);

8 }

9 /**

10 * 将发起人恢复到备忘录对象所记载的状态

11 */

12 public void restoreMemento(Memento memento){

13 this.state = memento.getState();

14 }

15 public String getState() {

16 return state;

17 }

18 public void setState(String state) {19 this.state = state;

20 System.out.println(\”当前状态：\” + this.state);

21 }

22 }

使用场景：

1. 需要保存和恢复数据的相关状态场景。

2. 提供一个可回滚（rollback）的操作。

3. 需要监控的副本场景中。

4. 数据库连接的事务管理就是用的备忘录模式。

18.访问者模式：封装一些作用于某种数据结构中的各元素的操作，它可以在不

改变数据结构的前提下定义作用于这些元素的新的操作。

使用场景：

1. 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施

一些依赖于其具体类的操作，也就说是用迭代器模式已经不能胜任的情景。

2. 需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免

让这些操作“污染”这些对象的类。

19.状态模式：当一个对象内在状态改变时允许其改变行为，这个对象看起来像

改变了其类。

使用场景：

1. 行为随状态改变而改变的场景

这也是状态模式的根本出发点，例如权限设计，人员的状态不同即使执行相同的

行为结果也会不同，在这种情况下需要考虑使用状态模式。

2. 条件、分支判断语句的替代者

20.解释器模式：给定一门语言，定义它的文法的一种表示，并定义一个解释

器，该解释器使用该表示来解释语言中的句子。

使用场景：

1. 重复发生的问题可以使用解释器模式

2. 一个简单语法需要解释的场景21.享元模式：使用共享对象的方法，用来尽可能减少内存使用量以及分享资

讯。

1 abstract class flywei{ }

2 public class Flyweight extends flywei{

3 Object obj ;

4 public Flyweight(Object obj){

5 this.obj = obj;

6 }

7 }

8 class FlyweightFactory{

9 private HashMap data;

10 public FlyweightFactory(){ data = new HashMap<>();}

11 public Flyweight getFlyweight(Object object){

12 if ( data.containsKey(object)){

13 return data.get(object);

14 }else {

15 Flyweight flyweight = new Flyweight(object);

16 data.put(object,flyweight);

17 return flyweight;

18 }

19 }

20 }

使用场景：

1. 系统中存在大量的相似对象。

2. 细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是

说对象没有特定身份。

3. 需要缓冲池的场景。

22.桥梁模式：将抽象和实现解耦，使得两者可以独立地变化。

Circle类将DrwaApi与Shape类进行了桥接，

1 interface DrawAPI {

2 public void drawCircle(int radius, int x, int y);

3 }

4 class RedCircle implements DrawAPI {5 @Override

6 public void drawCircle(int radius, int x, int y) {

7 System.out.println(\”Drawing Circle[ color: red, radius:

\”

8 + radius +\”, x: \” +x+\”, \”+ y +\”]\”);

9 }

10 }

11 class GreenCircle implements DrawAPI {

12 @Override

13 public void drawCircle(int radius, int x, int y) {

14 System.out.println(\”Drawing Circle[ color: green, radiu

s: \”

15 + radius +\”, x: \” +x+\”, \”+ y +\”]\”);

16 }

17 }

18 abstract class Shape {

19 protected DrawAPI drawAPI;

20 protected Shape(DrawAPI drawAPI){

21 this.drawAPI = drawAPI;

22 }

23 public abstract void draw();

24 }

25 class Circle extends Shape {

26 private int x, y, radius;

27 public Circle(int x, int y, int radius, DrawAPI drawAPI) {

28 super(drawAPI);

29 this.x = x;

30 this.y = y;

31 this.radius = radius;

32 }

33 public void draw() {

34 drawAPI.drawCircle(radius,x,y);

35 }

36 }

37 //客户端使用代码38 Shape redCircle = new Circle(100,100, 10, new RedCircle());

39 Shape greenCircle = new Circle(100,100, 10, new GreenCircle());

40 redCircle.draw();

41 greenCircle.draw();

使用场景：

1. 不希望或不适用使用继承的场景

2. 接口或抽象类不稳定的场景

3. 重用性要求较高的场景

23.模板方法模式：定义一个操作中的算法的框架，而将一些步骤延迟到子类

中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

使用场景：

1. 多个子类有公有的方法，并且逻辑基本相同时。

2. 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能

则由各个子类实现。

3. 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类

中，然后通过钩子函数（见“模板方法模式的扩展”）约束其行为。

本文作者及来源:Renderbus瑞云渲染农场https://www.renderbus.com