设计模式详解

ゝ一纸荒年。 2022-11-28 15:14 94阅读 0赞

### 设计模式的目的 ###

设计模式的出现是为了让程序有更好的：

*  代码重用性（DRY的实践，即不重复编写实现相同功能代码）
 *  可读性（编程规范性，便于其他程序员阅读与理解）
 *  可扩展性（便于增加新功能，也称为便于维护）
 *  可靠性（增加新功能后对原有功能不影响）
 *  使程序呈现高内聚低耦合的特性

### 设计模式七大原则 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 1]  
[https://blog.csdn.net/yanghao201607030101/article/details/108074983][https_blog.csdn.net_yanghao201607030101_article_details_108074983]

### 23种设计模式 ###

23种设计模式的UML类图链接：  
[https://www.processon.com/diagraming/5f3b37f41e085306e161aa3a][https_www.processon.com_diagraming_5f3b37f41e085306e161aa3a]

#### 创建型模式 ####

##### 1、简单工厂模式( Simple Factory Pattern ) #####

[https://design-patterns.readthedocs.io/zh\_CN/latest/creational\_patterns/simple\_factory.html\#][https_design-patterns.readthedocs.io_zh_CN_latest_creational_patterns_simple_factory.html]  
模式动机：对于若干继承自同一基类的子类，想要不通过具体类的名字而是通过参数来创建一个特定子类的对象，工厂提供了一个调用方便的方法，把有关特定子类的参数传入方法即可返回一个相应的特定对象，此时，就可以使用简单工厂模式。  
简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

简单工厂模式UML图如下：  
由三个角色组成：

1.  Product:基类，抽象产品，抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口
2.  Product:A、ProductB。。。具体产品，具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。
3.  Factory:工厂，工厂角色负责实现创建所有实例的内部逻辑

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 2]

**模式分析：**  
简单工厂模式将**对象的创建**和**对象本身业务处理**分离可以降低系统的耦合度，使得两者修改起来都相对容易。  
在调用工厂类的工厂方法时，由于工厂方法是静态方法，使用起来很方便，可通过类名直接调用，而且只需要传入一个简单的参数即可，在实际开发中，还可以在调用时将所传入的参数保存在XML等格式的配置文件中，修改参数时无须修改任何源代码。  
简单工厂模式最大的问题在于工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，这一点与开闭原则是相违背的。  
简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。  
**模式优点：**

*  实现了对责任的分割，将创建对象与消费对象分开。
 *  使用时无需知道具体类名，只需给出要创建的类需要的参数即可，减少记忆量
 *  可通过读取配置文件方式更改产生的具体对象，具有很大灵活性

**模式缺点：**  
由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。  
使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。  
系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。（最大缺点）  
简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

**适用环境：**  
工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。  
客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。  
**总结：**

*  创建型模式对类的实例化过程进行了抽象，能够将对象的创建与对象的使用过程分离。
 *  简单工厂模式又称为静态工厂方法模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
 *  简单工厂模式包含三个角色：工厂角色负责实现创建所有实例的内部逻辑；抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口；具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。
 *  简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。
 *  简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。
 *  简单工厂模式适用情况包括：工厂类负责创建的对象比较少；客户端只知道传入工厂类的参数，对于如何创建对象不关心。

##### 2、工厂方法模式(Factory Method Pattern) #####

**模式动机**：  
简单工厂模式集中了所有产品创建逻辑，一旦添加新产品就不得不修改工厂逻辑，不利于维护，也不符合ocp原则。现在对该系统进行修改，不再设计一个统一工厂类来统一负责所有产品的创建，而是将具体产品的创建过程交给专门的工厂子类去完成，我们先定义一个抽象的工厂类，再定义具体的工厂类来生成ProductA、ProductB等，它们实现在抽象工厂类中定义的方法。这种抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品，如果出现新的产品类型，只需要为这种新类型的按钮创建一个具体的工厂类就可以获得该新产品的实例，这一特点无疑使得工厂方法模式具有超越简单工厂模式的优越性，更加符合“开闭原则”。  
**模式定义**：  
工厂方法模式(Factory Method Pattern)又称为工厂模式，属于类创建型模式。  
在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作**延迟**到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

**模式结构**  
工厂方法模式UML图如下：  
组成角色：  
Product：抽象产品  
ProductA：具体产品A  
ProductB：具体产品B  
Factory：抽象工厂  
FactoryA：具体工厂A  
FactoryB：具体工厂B  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 3]

工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责哪一个产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

**工厂方法模式的优点**

*  在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。
 *  基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，是因为所有的具体工厂类都具有同一抽象父类。
 *  使用工厂方法模式的另一个优点是在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了。这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。  
    **工厂方法模式的缺点**
 *  在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
 *  由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

**模式扩展**

*  使用多个工厂方法：在抽象工厂角色中可以定义多个工厂方法，从而使具体工厂角色实现这些不同的工厂方法，这些方法可以包含不同的业务逻辑，以满足对不同的产品对象的需求。
 *  产品对象的重复使用：工厂对象将已经创建过的产品保存到一个集合（如数组、List等）中，然后根据客户对产品的请求，对集合进行查询。如果有满足要求的产品对象，就直接将该产品返回客户端；如果集合中没有这样的产品对象，那么就创建一个新的满足要求的产品对象，然后将这个对象在增加到集合中，再返回给客户端。

模式应用：  
JDBC中的工厂方法:

Connection conn=DriverManager.getConnection("jdbc:microsoft:sqlserver://loc
    alhost:1433; DatabaseName=DB;user=sa;password=");
    Statement statement=conn.createStatement();
    ResultSet rs=statement.executeQuery("select * from UserInfo");

**总结**

*  工厂方法模式又称为工厂模式，它属于类创建型模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
 *  工厂方法模式包含四个角色：抽象产品是定义产品的接口，是工厂方法模式所创建对象的超类型，即产品对象的共同父类或接口；具体产品实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，它们之间往往一一对应；抽象工厂中声明了工厂方法，用于返回一个产品，它是工厂方法模式的核心，任何在模式中创建对象的工厂类都必须实现该接口；具体工厂是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户调用，返回一个具体产品类的实例。
 *  如果抽象工厂下面只有一个具体工厂，那么工厂方法模式会退化为简单工厂模式。
 *  工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
 *  工厂方法模式的主要优点是增加新的产品类时无须修改现有系统，并封装了产品对象的创建细节，系统具有良好的灵活性和可扩展性；其缺点在于增加新产品的同时需要增加新的工厂，导致系统类的个数成对增加，在一定程度上增加了系统的复杂性。
 *  工厂方法模式适用情况包括：一个类不知道它所需要的对象的类；一个类通过其子类来指定创建哪个对象；将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定。

##### 3、抽象工厂模式(Abstract Factory Pattern) #####

模式动机：  
有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。  
而以往的工厂方法模式中，抽象工厂下的每个具体工厂只能生产一个具体的产品，因此将具体工厂改造成可以创建出分属于不同产品等级结构的一个产品族中的所有对象，这种方式也即抽象工厂模式，比工厂方法模式更为简单、有效率。

> 产品等级结构：例如冰箱与洗衣机是不同的产品等级结构。A品牌冰箱与B品牌冰箱属于统一产品等级结构。  
> 产品族：例如A品牌的冰箱与洗衣机是一个产品族。

**抽象工厂模式(Abstract Factory Pattern)**：抽象工厂角色中规定了所有可能被创建的产品集合，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

UML类图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 4]  
**优点：**

*  抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。
 *  当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。  
    增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。  
    **缺点：**
 *  在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。
 *  开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）。  
    **适用环境**  
    在以下情况下可以使用抽象工厂模式：
 *  一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。
 *  系统中有多于一个的产品族，而每次只使用其中某一产品族。
 *  属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
 *  系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。
 *

**工厂模式的退化**  
当抽象工厂模式中每一个具体工厂类只创建一个产品对象，也就是只存在一个产品等级结构时，抽象工厂模式退化成工厂方法模式；当工厂方法模式中抽象工厂与具体工厂合并，提供一个统一的工厂来创建产品对象，并将创建对象的工厂方法设计为静态方法时，工厂方法模式退化成简单工厂模式。

**抽象工厂模式>工厂方法模式>简单工厂模式**

##### 工厂模式小结 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 5]

##### 4、建造者模式 #####

**造者模式(Builder Pattern)**：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。  
**建造者模式与抽象工厂模式的比较:**

与抽象工厂模式相比， 建造者模式返回一个组装好的完整产品 ，而 抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族。  
在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产品对象，而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤，它侧重于一步步构造一个复杂对象，返回一个完整的对象。  
如果将抽象工厂模式看成 汽车配件生产工厂 ，生产一个产品族的产品，那么建造者模式就是一个 汽车组装工厂 ，通过对部件的组装可以返回一辆完整的汽车。  
采用抽象工厂模式不需要关心构建过程，只需要关心产品由什么工厂类生产即可。采用建造者模式则要求按照蓝图构造产品，主要目的是组装零件返回完整的一个产品。

建造者模式包含如下角色：

Builder：抽象建造者  
ConcreteBuilder：具体建造者  
Director：指挥者  
Product：产品角色  
UML类图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 6]  
应用场景;  
在以下情况下可以使用建造者模式：

1.  需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
2.  需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
3.  对象的创建过程独立于创建该对象的类。在建造者模式中引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类中。
4.  隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

**实际应用：**  
在很多游戏软件中，地图包括天空、地面、背景等组成部分，人物角色包括人体、服装、装备等组成部分，可以使用建造者模式对其进行设计，通过不同的具体建造者创建不同类型的地图或人物。

**总结：**

*  建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。建造者模式属于对象创建型模式。
 *  建造者模式包含如下四个角色：抽象建造者为创建一个产品对象的各个部件指定抽象接口；具体建造者实现了抽象建造者接口，实现各个部件的构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象；产品角色是被构建的复杂对象，包含多个组成部件；指挥者负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造
 *  在建造者模式的结构中引入了一个指挥者类，该类的作用主要有两个：一方面它隔离了客户与生产过程；另一方面它负责控制产品的生成过程。指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象。
 *  建造者模式的主要优点在于客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象，每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，符合“开闭原则”，还可以更加精细地控制产品的创建过程；其主要缺点在于由于建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，因此其使用范围受到一定的限制，如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。
 *  建造者模式适用情况包括：需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性；需要生成的产品对象的属性相互依赖，需要指定其生成顺序；对象的创建过程独立于创建该对象的类；隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同类型的产品。

##### 5、原型模式 #####

模式动机：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，在运行期建立和删除原型。  
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。  
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

该模式UML类图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 7]

共有三个角色：

*  客户(Client)角色：客户类提出创建对象的请求；也就是我们用户使用复制粘贴的功能。
 *  抽象原型(Prototype)角色：此角色定义了的具体原型类所需的实现的方法。也就是定义一个文件，说明一下它有被克隆复制的功能。
 *  具体原型(Concrete Prototype)角色：实现抽象原型角色的克隆接口，实现复制自己的操作。就是我们的文件实现了可以被复制的功能。

在 Java 中，所有的 Class 都继承自 Object ，而在 Object 上，存在一个 clone() 方法，所有调用 clone() 方法的对象，都必须实现 Cloneable 接口，该接口表示此类可以复制，且具有复制能力。

直接调用Object的clone()方法实现的是浅拷贝，要想实现深拷贝需要自己重写clone（），或者序列化该类以序列化方式实现深拷贝。以下的例子展示了深拷贝的两种实现方式。

**浅拷贝**：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝。

**深拷贝**：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容。

深拷贝实例：

原型类：

public class DeepProtoType implements Serializable, Cloneable{ 
    	
    	public String name; //String 属性
    	public DeepCloneableTarget deepCloneableTarget;// 引用类型
    	public DeepProtoType() { 
    		super();
    	}
    	
    	
    	//深拷贝 - 方式 1 使用clone 方法
    	@Override
    	protected Object clone() throws CloneNotSupportedException { 
    		
    		Object deep = null;
    		//这里完成对基本数据类型(属性)和String的克隆
    		deep = super.clone(); 
    		//对引用类型的属性，进行单独处理
    		DeepProtoType deepProtoType = (DeepProtoType)deep;
    		deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
    		
    		// TODO Auto-generated method stub
    		return deepProtoType;
    	}
    	
    	//深拷贝 - 方式2 通过对象的序列化实现 (推荐)
    	
    	public Object deepClone() { 
    		
    		//创建流对象
    		ByteArrayOutputStream bos = null;
    		ObjectOutputStream oos = null;
    		ByteArrayInputStream bis = null;
    		ObjectInputStream ois = null;
    		
    		try { 
    			
    			//序列化
    			bos = new ByteArrayOutputStream();
    			oos = new ObjectOutputStream(bos);
    			oos.writeObject(this); //当前这个对象以对象流的方式输出
    			
    			//反序列化
    			bis = new ByteArrayInputStream(bos.toByteArray());
    			ois = new ObjectInputStream(bis);
    			DeepProtoType copyObj = (DeepProtoType)ois.readObject();
    			
    			return copyObj;
    			
    		} catch (Exception e) { 
    			// TODO: handle exception
    			e.printStackTrace();
    			return null;
    		} finally { 
    			//关闭流
    			try { 
    				bos.close();
    				oos.close();
    				bis.close();
    				ois.close();
    			} catch (Exception e2) { 
    				// TODO: handle exception
    				System.out.println(e2.getMessage());
    			}
    		}
    		
    	}
    	
    }

原型种的引用类：

public class DeepCloneableTarget implements Serializable, Cloneable { 
    	
    	/** * */
    	private static final long serialVersionUID = 1L;
    
    	private String cloneName;
    
    	private String cloneClass;
    
    	//构造器
    	public DeepCloneableTarget(String cloneName, String cloneClass) { 
    		this.cloneName = cloneName;
    		this.cloneClass = cloneClass;
    	}
    
    	//因为该类的属性，都是String , 因此我们这里使用默认的clone完成即可
    	@Override
    	protected Object clone() throws CloneNotSupportedException { 
    		return super.clone();
    	}
    }

client类：

public class Client { 
    
    	public static void main(String[] args) throws Exception { 
    		// TODO Auto-generated method stub
    		DeepProtoType p = new DeepProtoType();
    		p.name = "宋江";
    		p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");
    		
    		//方式1 完成深拷贝
    		
    // DeepProtoType p2 = (DeepProtoType) p.clone();
    // 
    // System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
    // System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
    	
    		//方式2 完成深拷贝
    		DeepProtoType p2 = (DeepProtoType) p.deepClone();
    		
    		System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
    		System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
    	
    	}
    }

##### 6、单例模式 #####

单例模式(Singleton Pattern)：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。  
单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

**实现方式**共有8种：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 8]

*  单例模式确保某一个类**只有一个实例**，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。
 *  单例模式只包含一个单例角色：在单例类的内部实现只生成一个实例，同时它提供一个静态的工厂方法，让客户可以使用它的唯一实例；为了防止在外部对其实例化，将其构造函数设计为私有。
 *  单例模式的**目的**是保证一个类仅有一个实例，并提供一个访问它的全局访问点。**单例类拥有一个私有构造函数，确保用户无法通过new关键字直接实例化它**。除此之外，该模式中包含一个静态私有成员变量与静态公有的工厂方法。该工厂方法负责检验实例的存在性并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建。
 *  单例模式的主要**优点**在于提供了对唯一实例的受控访问并可以节约系统资源；其主要**缺点**在于因为缺少抽象层而难以扩展，且单例类职责过重。
 *  单例模式**适用情况**包括：系统只需要一个实例对象；客户调用类的单个实例只允许使用一个公共访问点。

创建型模式结束。

写博客记录学习比较花时间，目前自己还很菜，打算先先学习，有积累后再做学习，所以，只写到这里。  
其余的设计模式可以参照这个两个文档：  
[https://design-patterns.readthedocs.io/zh\_CN/latest/behavioral\_patterns/behavioral.html][https_design-patterns.readthedocs.io_zh_CN_latest_behavioral_patterns_behavioral.html]  
还有一个尚硅谷的图解设计模式，课程可在b站上找到，课程文档资料：  
链接：https://pan.baidu.com/s/11kBV4YDlE3KSnsw0nI0QHw  
提取码：9et4  
里面的文档很详细，可以直接用它的教学文档加上一个文档搭配看。  
当然，还有菜鸟教程这些也有，但是我觉得这两个比较好。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/f4e0f621c7004d19b1afa05bf974a047.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221124/e1c624194ce5470892ff73e52cd349bf.png
[https_blog.csdn.net_yanghao201607030101_article_details_108074983]: https://blog.csdn.net/yanghao201607030101/article/details/108074983
[https_www.processon.com_diagraming_5f3b37f41e085306e161aa3a]: https://www.processon.com/diagraming/5f3b37f41e085306e161aa3a
[https_design-patterns.readthedocs.io_zh_CN_latest_creational_patterns_simple_factory.html]: https://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/simple_factory.html#
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221124/b672bdb659054cc3af7cac64fade677f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221124/89ff659dddca4c068cff8b9914ebed5d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221124/61e49b2f5e81415fb33b75d2fec84f46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221124/04211cff3aab48bbb95cc396555dfbb8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221124/e1bc74f27c4f408d89ea7753f0adea8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221124/1c28aa37f25d49539cedc00304f5d910.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdoYW8yMDE2MDcwMzAxMDE_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221124/24dc81dfa5844f0dbac2f3d996848f15.png
[https_design-patterns.readthedocs.io_zh_CN_latest_behavioral_patterns_behavioral.html]: https://design-patterns.readthedocs.io/zh_CN/latest/behavioral_patterns/behavioral.html