设计模式--创建型设计模式

一、 设计模式的目的

​ 编写软件过程中，可能面临来自耦合性、内聚性、可维护性、可扩展性、重用性、灵活性等多方面的挑战，设计模式是为了让程序具有更好的：

1. 代码重用性（即相同的代码，不用多次编写）
2. 可读性（即编程规范性，便于其他程序员的阅读和理解）
3. 可扩展性（即需要新增功能时，非常方便，便于维护）
4. 使程序呈现高内聚、低耦合的特性
5. 可靠性（即新增功能后，对原来的功能没有影响）

---

二、设计模式七大原则

1. 单一职责原则

   基础介绍

   对类来说，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2。

   应用实例

   1）交通方式

2. 接口隔离原则(Interface Segregation Principle)

   基础介绍

   1）客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

   2）UML类图示例

   

   其中要求类A通过接口会依赖（使用）类B，但类A只会使用接口的1、2、3方法；

   A a = new A(); a.operation1(new B());

   要求类C通过接口会依赖（使用）类D，但类D只会使用接口的1、4、5方法

   3）类A通过接口依赖类B，类C通过接口依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D就会实现他们不需要的方法，这不符合“接口隔离原则”。

   4）遵循“接口隔离原则”的处理方式：将接口Interface1拆分为几个独立的接口，类A和类C分别与其需要的接口建立依赖关系，这样就遵循了“接口隔离原则”。UML类图如下：

3. 依赖倒转（倒置）原则

   基本介绍

   依赖倒置原则是指：

   1）高层模块不应该依赖低层模块，二者都应该依赖其抽象

   2）抽象不应该依赖细节，细节应该依赖抽象

   3）依赖倒置的中心思想是：面向接口编程

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

   依赖关系传递的三种实现方式

   1）接口传递

   2）构造方法传递

   3）setter方式传递

4. 里氏替换原则

   里氏替换原则是对oo中继承性的思考和说明：

   1）继承的含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然不强制要求所有的子类必须遵循这些规范，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏；

   2）继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加了对象之间的耦合性。如果一个类被其他的类继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改所有涉及的子类都有可能出现故障；

   3）所有在编程中使用“里氏替换原则”类实现继承。

   基础介绍（实际是对继承的问题说明）

   1）所有引用基类的地方必须能透明地使用其子类的对象；

   2）在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法；

   3）继承实际上会让两个类耦合性增强，在适当的情况下，可以通过聚合、组合、依赖来解决问题。

   实现

   通用的做法：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖、聚合、组合灯关系替代。

   代码示例

   interface Base {
   }
   
   class A implements Base{
        Integer sub(int a, int b){
           return a - b;
       }
   }
   
   class B implements Base{
       A a = new A(); // 组合
       Integer add(int a, int b) {
           return a + b;
       }
       Integer operation(int a, int b){
           return this.a.sub(a, b) + a;
       }
   }
   

   UML类图

5. 开闭原则

   基础介绍

   1）编程中最基础、最重要的设计原则；

   2）一个软件实体如类、模块、函数应该对外扩展开放，对修改关闭。用抽象构建框架，用实现扩展细节；

   3）当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化；

   4）编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则。

6. 迪米特法则

   基础介绍

   1）一个对象应该对其他对象保持最少的了解；

   2）类与类关系越密切，耦合度越大；

   3）迪米特法则又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。对于被依赖的类不管多复杂，都尽量讲逻辑封装在类的内部。对外除了提供的public方法，不对外泄漏任何信息；

   4）更简单的定义：只与直接的朋友通信；

   5）直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象间存在耦合关系，则他们就是朋友关系。耦合的方式很多，依赖、关联、组合、聚合等。其中，出现成员变量、方法参数、方法返回值中的类为直接的朋友。出现在局部变量的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

   迪米特法则注意事项和细节

   1）核心是降低类之间的耦合；

   2）注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类之间的耦合，并不是完全没有依赖关系。

7. 合成复用原则

   基本介绍

   原则是尽量使用合成、聚合的方式，而不是使用继承。

   示例

如果让B类去使用A类的方法，使用继承就会让B和A的耦合性增强。

优化方案

1）使用依赖

2）使用聚合

3）使用组合

---

三、类图6大关系

1. 依赖：类之间相互使用就是一种依赖关系

   代码示例

   public class PersonServiceBean {
       private PersonDao personDao; // 成员变量
       public void save(Person person) {} // 方法入参
       public IDCard getIDCard(Integer personId){} // 方法返回值
       public void modify() {
           Department department = new Department(); // 方法私有变量
       }
   }
   class PersonDao{}
   
   class Person{}
   
   class IDCard{}
   
   class Department{}
   

   UML类图

2. 继承

3. 实现

4. 关联

   解释说明

   实际是类与类之间的联系，具有导航性，即双向关系还是单向关系。

   单向一对一关系：类A---->类B，但类B–x–>类A；

双向一对一关系：类A---->类B，且类B---->类A；

5. 聚合

   解释说明

   表示整体与部分的关系，整体与部分可以分开

   代码示例

       public class Computer {
       private Mouse mouse;  // 创建Computer对象时可以不创建该对象，只有调用了set方法才会创建
   
       private Monitor monitor;
   
       public void setMouse(Mouse mouse) {
           this.mouse = new Mouse();
       }
   
       public void setMonitor(Monitor monitor) {
           this.monitor = new Monitor();
       }
   }
   
   class Mouse{}
   
   class Monitor{}
   

   UML类图

6. 组合

   解释说明

   也是整体与部分的关系，但是整体与部分不可分开。就类似人体各部分结构的关联性一样。

   代码示例

   class Person{
       private IDCard idCard; // 类IDCard与Person就是聚合关系
       private Head head = new Head(); // 类Head与Person就是组合关系，因为两者不可分割
   }
   
   class IDCard{}
   
   class Head{}
   

   UML类图

---

四、Java设计模式分类

​ 设计模式分为三种类型，共23种：

1. 创建型模式：单例模式、工厂模式（简单工厂模式，工厂方法模式）、抽象工厂模式、原型模式、建造者模式；（对对象创建的设计）
2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式；（软件结构角度，如何让软件更具伸缩性、扩展性）
3. 行为型模式：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式。（重在方法角度的设计）

---

五、创建型设计模式

1. 单例模式

基本介绍 设计层面保证一个类只能产生一个实例

类的单例模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的静态方法。

单例模式总共有8种实现方法：

• 饿汉式（静态常量）
• 饿汉式（静态代码块）
• 懒汉式（线程不安全）
• 懒汉式（线程安全，同步方法）
• 懒汉式（线程不安全，同步代码块）
• 双重检查
• 静态内部类
• 枚举

1）饿汉式（静态常量）实现（可用） JDK的 RunTIme类就是该实现方法

步骤如下：

• 构造器私有化（保证其他类不能通过new创建该对象）
• 类的内部创建对象
• 向外暴露一个静态的公共方法。getInstance()

代码示例：

/**
 * <pre>
 * 描述: 单例模式实现方式一：饿汉式（静态常量）
 * </pre>
 */
public class SingletonImplement1 {

    /**
     * 1. 构造器私有化
     */
    private SingletonImplement1() {
    }

    /**
     * 2. 本类内部创建静态对象实例
     */
    private final static SingletonImplement1 INSTANCE = new SingletonImplement1();

    /**
     * 3. 提供一个公有的静态方法，返回实例对象
     * @return
     */
    public static SingletonImplement1 getInstance() {
        return INSTANCE;
    }
}

优缺点总结：

优点：在类装载的时候就完成实例化，避免了线程同步问题；

缺点：在类加载的时候就完成实例化，没有达到懒加载效果，如果从始至终都未使用该实例，会造成资源浪费。

2）饿汉式（静态代码块）实现（可用）**

代码示例：

/**
 * <pre>
 * 描述: 单例模式实现方式二：饿汉式（静态代码块）
 * </pre>
 */
public class SingletonImplement2 {

    /**
     * 1. 构造器私有化
     */
    private SingletonImplement2() {
    }

    /**
     * 2. 本类内部创建静态对象
     */
    private static SingletonImplement2 instance ;

    /**
     * 3. 静态代码块内创建实例
     */
    static {
        instance = new SingletonImplement2();
    }

    /**
     * 4. 提供一个公有的静态方法，返回实例对象
     * @return
     */
    public static SingletonImplement2 getInstance() {
        return instance;
    }
}

优缺点总结：

也是在类装载的时候，就执行了静态代码块的代码，创建了对象实例。也可能造成资源浪费。

3）懒汉式（线程不安全）实现（不可用）

代码示例：

/**
 * <pre>
 * 描述: 单例模式实现方式三：懒汉式（线程不安全）
 * </pre>
 *
 * @version 1.0
 * @author: Kyle Wong
 * @date: 2022/7/23 10:27
 */
public class SingletonImplement3 {

    /**
     * 1. 构造器私有化
     */
    private SingletonImplement3() {
    }

    /**
     * 2. 本类内部创建静态对象
     */
    private static SingletonImplement3 instance ;
    
    /**
     * 3. 提供一个公有的静态方法，在调用该方法时才创建对象
     * @return
     */
    public static SingletonImplement3 getInstance() {
        if (instance == null) {
            instance = new SingletonImplement3();
        }
        return instance;
    }
}

优缺点总结：

优点：起到了懒加载效果，只有在调用getInstance()方法时，才创建对象实例。

缺点：只适用于单线程。多线程下由于对if(instance == null)的判断，可能会创建多个对象实例。实际开发中，不适用。

4）懒汉式（线程安全，同步方法）实现（效率太低，不推荐使用）

代码示例：

/**
 * <pre>
 * 描述: 单例模式实现方式四：懒汉式（线程安全，同步方法）
 * </pre>
 */
public class SingletonImplement4 {

    /**
     * 1. 构造器私有化
     */
    private SingletonImplement4() {
    }

    /**
     * 2. 本类内部创建静态对象
     */
    private static SingletonImplement4 instance ;

    /**
     * 3. 提供一个公有的静态方法，在调用该方法时才创建对象
     *    同步方法，解决了线程不安全问题
     * @return
     */
    public static synchronized SingletonImplement4 getInstance() {
        if (instance == null) {
            instance = new SingletonImplement4();
        }
        return instance;
    }
}

优缺点总结：

优点：解决了线程不安全问题；

缺点：效率较低；不推荐使用

5）懒汉式（线程不安全，同步代码块）实现（不能使用）

代码示例

/**
 * <pre>
 * 描述: 单例模式实现方式五：懒汉式（线程不安全，同步代码块）
 * </pre>
 */
public class SingletonImplement5 {

    /**
     * 1. 构造器私有化
     */
    private SingletonImplement5() {
    }

    /**
     * 2. 本类内部创建静态对象
     */
    private static SingletonImplement5 instance ;

    /**
     * 3. 提供一个公有的静态方法，在调用该方法时才创建对象
     * @return
     */
    public static SingletonImplement5 getInstance() {
        if (instance == null) {
            synchronized (SingletonImplement5.class) {
                instance = new SingletonImplement5();
            }
        }
        return instance;
    }
    
     /**
     * 给方法添加synchronized就可以保证该种创建方式线程安全
     * @return
     */
    public static synchronized SingletonImplement5 getInstance() {
        if (instance == null) {
            synchronized (SingletonImplement5.class) {
                instance = new SingletonImplement5();
            }
        }
        return instance;
    }
}

优缺点总结：

优点：解决了方案4的效率太低问题；

缺点：线程不安全

6）双重检查实现（可用）

代码示例：

/**
 * <pre>
 * 描述: 单例模式实现方式六：双重检查
 * </pre>
 */
public class SingletonImplement6 {

    /**
     * 1. 构造器私有化
     */
    private SingletonImplement6() {
        // 该方法主要阻住通过反射被调用！
        if (instance != null) {
            return new IllegalStateException("Already initialized.");
        }
    }

    /**
     * 2. 本类内部创建静态对象
     */
    private static volatile SingletonImplement6 instance ;

    /**
     * 3. 提供一个公有的静态方法，在调用该方法时才创建对象
     *    进行双重判空检查，解决了线程安全问题、懒加载问题
     * @return
     */
    public static SingletonImplement6 getInstance() {
        if (instance == null) {
            synchronized (SingletonImplement6.class) {
                if (instance == null) {
                    instance = new SingletonImplement6();
                }
            }
        }
        return instance;
    }
}

7）静态内部类实现（可用）

代码示例：

package singleton;

/**
 * <pre>
 * 描述: 单例模式实现方式七：静态内部类
 * </pre>
 */
public class SingletonImplement7 {

    /**
     * 1. 构造器私有化
     */
    private SingletonImplement7() {
    }

    /**
     * 2. 本类内部创建静态内部类，声明静态变量，并创建实例
     *    静态内部类不会在类SingletonImplement7加载时加载，保证了懒加载的效果
     *    并且JVM加载类时是线程安全的，所以静态内部类的加载是线程安全的
     */
    private static class SingletonInstance {
        private static final SingletonImplement7 INSTANCE = new SingletonImplement7();
    }

    /**
     * 3. 提供一个公有的静态方法，调用该方法时 返回静态内部类中的静态属性
     * @return
     */
    public static SingletonImplement7 getInstance() { 
        return SingletonInstance.INSTANCE;
    }
}

优缺点说明：

优点：该方式采用了类加载机制来保证初始化实例时只有一个线程。

​ 静态内部类不会在外部内装载时立即实例化，而是需要调用getInstance()方法，才会装载静态内部类， 从而完成外部内的实例化。

​ 类的静态属性只会在第一次装载类的时候初始化

8）枚举类实现（可用）

代码示例：

/**
 * <pre>
 * 描述: 单例模式实现方式八：枚举类
 * </pre>
 */
public class SingletonImplement8 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        instance1.test();
        Singleton instance2 = Singleton.INSTANCE;
        instance2.test();
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }

    enum Singleton {
        INSTANCE;
        private void test() {
            System.out.println("枚举类实现单例模式");
        }
    }
}

优缺点说明：

优点：避免了多线程同步问题，还能阻止反序列化重新创建新的对象。

单例模式注意事项：

1）单例模式保证了系统中该类只有一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能（比如数据库连接对象，至少要建立7次）；

2）单例模式的使用场景：需要频繁进行创建和销毁的对象、创建对象耗时过多或耗费资源过多，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂）。

2. 简单工厂模式

基础介绍 （JDK的DateFormat类就是用了简单工厂模式）

简单工厂模式又称静态工厂模式，属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个工厂类来负责创建其他类的实例，被创建的类通常都有共同的父类。核心就是这个工厂类。

UML类图示例

代码示例

/**
 * 1. 创建一个抽象的产品类 （大类）
 */
abstract class Product {
    abstract void print();
}

/**
 * 2. 创建子类
 */
class ProductA extends Product{

    @Override
    void print() {
        System.out.println("产品A");
    }
}

class ProductB extends Product{

    @Override
    void print() {
        System.out.println("产品B");
    }
}

/**
 * 3. 创建工厂类，获取对象实例的方法是静态方法
 */
public class SimpleFactory {
    private static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else {
            return new ProductB();
        }
    }

    public static void main(String[] args) {
        // 客户端调用工厂方法，传入类型参数，就可以创建对应类的实例
        Product product = SimpleFactory.createProduct("A");
        product.print();
    }
}

优缺点说明：

优点：对象的创建完全交给工厂类完成，将对象的创建与使用完全分离，客户端不关心对象是怎么创建出来的，只管使用。

缺点：不够灵活，如果新增实现类，就需要修改工厂类中的方法。如果实现类较多的话，工厂类中的方法就会非常复杂。工厂类的责任相对过重，不易于扩展复杂的产品结构。

3. 工厂方法模式

基础介绍 （工厂方法模式在slf4j中的使用，主要是log方面的使用）

工厂方法模式主要解决产品扩展的问题。在简单工厂模式中，随着产品链的丰富，工厂类的职责会越来越重，有点像万能工厂，不易于维护。根据单一职责原则，可以将工厂类的职责进行划分，专人干专事。比如：Python工厂专门创建Python相关的类，Java工厂专门创建Java需要的类。

UML类图示例

代码示例

public class FactoryMethod {
    public static void main(String[] args) {
        JavaFactory javaFactory = new JavaFactory();
        Course course = javaFactory.createCourse();
        course.showCourseContent(); // 输出结果为：这是Java课程
    }
}
 
/**
 * 产品抽象类
 */
abstract class Course{
    abstract void showCourseContent();
}

/**
 * 具体产品 JavaCourse
 */
class JavaCourse extends Course{

    @Override
    public void showCourseContent() {
        System.out.println("这是Java课程");
    }
}

/**
 * 具体产品 PythonCourse
 */
class PythonCourse extends Course{

    @Override
    public void showCourseContent() {
        System.out.println("这是Python课程");
    }
}

/**
 * 抽象工厂类
 */
abstract class CourseFactory{
    abstract Course createCourse();
}

/**
 * JavaFactory工厂类，专门生产JavaCourse对象
 */
class JavaFactory extends CourseFactory{

    @Override
    public Course createCourse() {
        return new JavaCourse();
    }
}

/**
 * PythonFactory工厂类，专门生产PythonCourse对象
 */
class PythonFactory extends CourseFactory{

    @Override
    public Course createCourse() {
        return new PythonCourse();
    }
}

工厂方法模式在slf4j中的使用，主要是log方面的使用

4. 抽象工厂模式

基础介绍

抽象工厂模式其实是对工厂方法模式的扩展，当只有一个产品体系的时候，就会还原成工厂方法模式。

UML类图示例 有多个产品体系

UML类图示例 只有一个产品体系时会还原成工厂方法模式

代码示例

abstract class Factory{
    abstract ProductA createProductA();
    abstract ProductB createProductB();
}

class ConcreteFactory1 extends Factory{

    @Override
    ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

class ConcreteFactory2 extends Factory{

    @Override
    ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

abstract class ProductA{
    abstract void showProductAContent();
}

abstract class ProductB{
    abstract void showProductBContent();
}

class ConcreteProductA1 extends ProductA{

    @Override
    void showProductAContent() {
        System.out.println("这是产品A1");
    }
}

class ConcreteProductA2 extends ProductA{

    @Override
    void showProductAContent() {
        System.out.println("这是产品A2");
    }
}

class ConcreteProductB1 extends ProductB{

    @Override
    void showProductBContent() {
        System.out.println("这是产品B1");
    }
}

class ConcreteProductB2 extends ProductB{

    @Override
    void showProductBContent() {
        System.out.println("这是产品B2");
    }
}

public class AbstractFactory {
    public static void main(String[] args) {
        ConcreteFactory1 concreteFactory1 = new ConcreteFactory1();
        concreteFactory1.createProductA().showProductAContent();
        concreteFactory1.createProductB().showProductBContent();
        System.out.println("---------------------------------");
        ConcreteFactory2 concreteFactory2 = new ConcreteFactory2();
        concreteFactory2.createProductA().showProductAContent();
        concreteFactory2.createProductB().showProductBContent();
    }
}
// 输出结果
    这是产品A1
    这是产品B1
    ---------------------------------
    这是产品A2
    这是产品B2

优缺点说明：

优点：可以使具体工厂创建多个“大类”（产品体系）对象。比如 ConcreteFactory1可以创建ConcreteProductA1、ConcreteProductB1两种类型的产品对象。

缺点：当新增产品体系时，需要修改工厂类，违背了开闭原则。

源码使用： Connection

5. 原型模式

基础介绍

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

允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节；

工作原理是：通过将一个原型对象传给要发动创建的对象，这个要发动创建的对象通过请求原型对象开呗他们自己来实施创建，即对象.clone()。

可以理解为：一个对象的产生可以不由零起步，直接从一个已经具备一定雏形的对象克隆，然后再修改为生产需要的对象。

浅拷贝

1）对于数据类型是基本类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值赋值一份给新的对象。

2）对于数据类型是引用数据类型的成员变量，比如成员变量是某个数组、某个类的对象等，浅拷贝会进行引用传递，也就是说只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改成员变量回影响到其他对象的该成员变量。

3）浅拷贝使用默认的clone()方法来实现：super.clone();

4）代码示例：

package prototype;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * <pre>
 * 描述: 原型模式--浅拷贝
 * </pre>
 *
 * @version 1.0
 * @author: Kyle Wong
 * @date: 2022/8/17 15:01
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PrototypeShallowClone implements Cloneable{

    private String name;

    private Integer age;

    private float score;

    private Course course;

    @Override
    public String toString() {
        return "PrototypeShallowClone{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", course=" + course.hashCode() +
                '}';
    }

    @Override
    protected Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }
}

@Data
@AllArgsConstructor
class Course {
    private String courseId;

    private String courseName;
}

class AppClient {
    public static void main(String[] args) {
        PrototypeShallowClone prototypeShallowClone1 = new PrototypeShallowClone("Kyle", 28, 95.5f, new Course("1", "Chinese"));
        PrototypeShallowClone prototypeShallowClone2 = (PrototypeShallowClone)prototypeShallowClone1.clone();
        prototypeShallowClone2.setAge(25);
        prototypeShallowClone2.setName("Nn");
        prototypeShallowClone2.setScore(98f);
        System.out.println(prototypeShallowClone1.toString());
        System.out.println(prototypeShallowClone2.toString());
    }
}

// 运行结果：
// PrototypeShallowClone{name='Kyle', age=28, score=95.5, course=-1883977295}
// PrototypeShallowClone{name='Nn', age=25, score=98.0, course=-1883977295}
// 运行结果可看出 Course指向同一个对象

5）浅拷贝示意图

深拷贝

1）要复制对象的所有基本数据类型的成员变量值

2）为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，知道该对象可达的所有对象。也就是，深拷贝要对整个对象进行拷贝

3）深拷贝实现方式1：重写clone()方法

4）深拷贝实现方式2：通过对象序列化实现

5）深拷贝代码示例：

package prototype;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.*;

/**
 * <pre>
 * 描述: 原型模式--深拷贝
 * </pre>
 *
 * @version 1.0
 * @author: Kyle Wong
 * @date: 2022/8/17 15:01
 */
@AllArgsConstructor
@NoArgsConstructor
public class PrototypeDeepClone implements Serializable, Cloneable{

    private String name;

    private Integer age;

    private float score;

    private Course1 course;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public float getScore() {
        return score;
    }

    public void setScore(float score) {
        this.score = score;
    }

    public Course1 getCourse() {
        return course;
    }

    public void setCourse(Course1 course) {
        this.course = course;
    }

    @Override
    public String toString() {
        return "PrototypeDeepClone{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", course=" + course.hashCode() +
                '}';
    }

    /**
     * 深拷贝方式1，使用clone方法
     * 该方式适用于 引用数据类型较少的情况
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    protected Object clone() {
        Object deep = null;
        try {
            // 先完成基本数据类型和String的克隆
            deep = super.clone();
            PrototypeDeepClone prototypeDeepClone = (PrototypeDeepClone)deep;
            // 对引用数据类型做单独处理
            prototypeDeepClone.course = (Course1)course.clone();
            return prototypeDeepClone;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 深拷贝2：通过对象的序列化实现（推荐）
     */
    public Object deepClone2() {
        // 创建流对象
        ByteArrayOutputStream byteArrayOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        ByteArrayInputStream byteArrayInputStream = null;
        ObjectInputStream objectInputStream = null;
        try {
            // 序列化
            byteArrayOutputStream = new ByteArrayOutputStream();
            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            // 当前对象已输出流方式输出
            objectOutputStream.writeObject(this);

            // 反序列化
            byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            objectInputStream = new ObjectInputStream(byteArrayInputStream);
            PrototypeDeepClone object = (PrototypeDeepClone)objectInputStream.readObject();
            return object;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            // 关闭流
            try {
                byteArrayOutputStream.close();
                objectOutputStream.close();
                byteArrayInputStream.close();
                objectInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

@AllArgsConstructor
class Course1 implements Serializable, Cloneable{
    private String courseId;
    private String courseName;

    public String getCourseId() {
        return courseId;
    }

    public void setCourseId(String courseId) {
        this.courseId = courseId;
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class AppClient1 {
    public static void main(String[] args) {
        // 方式1测试
        System.out.println("深拷贝实现方式1");
        PrototypeDeepClone prototypeDeepClone1 = new PrototypeDeepClone("Kyle", 28, 95.5f, new Course1("1", "Chinese"));
        PrototypeDeepClone prototypeDeepClone2 = (PrototypeDeepClone)prototypeDeepClone1.clone();
        prototypeDeepClone2.setAge(25);
        prototypeDeepClone2.setName("Nn");
        prototypeDeepClone2.setScore(98f);
        System.out.println(prototypeDeepClone1.toString());
        System.out.println(prototypeDeepClone2.toString());

        // 方式2测试
        System.out.println("深拷贝实现方式2");
        PrototypeDeepClone prototypeDeepClone3 = (PrototypeDeepClone)prototypeDeepClone1.deepClone2();
        prototypeDeepClone3.setAge(25);
        prototypeDeepClone3.setName("Nn");
        prototypeDeepClone3.setScore(98f);
        System.out.println(prototypeDeepClone1.toString());
        System.out.println(prototypeDeepClone3.toString());
    }
}

// 运行结果：
// 深拷贝实现方式1
// PrototypeDeepClone{name='Kyle', age=28, score=95.5, course=1735600054}
// PrototypeDeepClone{name='Nn', age=25, score=98.0, course=21685669}
// 深拷贝实现方式2
// PrototypeDeepClone{name='Kyle', age=28, score=95.5, course=1735600054}
// PrototypeDeepClone{name='Nn', age=25, score=98.0, course=1922154895}
// 运行结果可看出两张深拷贝实现方式 Course指向不同对象

6）深拷贝示例图：

深拷贝与浅拷贝工具类

1）深拷贝：SerializationUtils

2）浅拷贝：BeanUtils

原型模式的优点

1）原型模式是在内存中进行二进制流的拷贝，要比直接new一个对象性能好，特别是在一个循环体内创建大量对象时；

2）原型模式可以简化对象的创建过程，可以直接拷贝现有的原型实例的值，实现对象复用。

6. 建造者模式（生成器模式）

基本介绍（JDK中StringBuilder就是用了建造者模式）

1）可以将复杂对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象；

2）建造者模式是一步一步创建一个复杂的对象，允许用户只通过指定复杂对象的类型和内容就可以构建他们，用户不需要知道内部的具体构建细节。

使用示例

@Build注解

---