Java原型模式详解：克隆人案例【深浅克隆】_深克隆使用的例子有哪些

前言
在许多情况下，我们需要创建对象的副本，比如在初始化操作比较复杂或者需要大量资源的情况下。在这些情况下，我们可以使用原型模式来避免重复创建对象，提高程序的性能。本文将介绍Java中的原型模式以及如何在实际应用中使用它。

一、原型模式概述

原型模式（Prototype Pattern）属于创建型设计模式，它的核心思想是通过克隆一个已经存在的对象（原型）来返回新的对象，而不是通过实例化类来创建新的对象。关于对象克隆，在Object类中已经提供了相应的方法clone()，我们只需要调用即可。这种方式在某些场景下，能够大大提高对象创建的效率。

1.1 如何实现？

Java中的原型模式实现很简单，只需要在需要被复制的对象上实现Cloneable接口，并且重写Object中的clone方法即可。

Cloneable接口是 Java 中的一个标记接口，它没有任何方法，只是作为一个标识，告诉编译器该类可以被克隆。当一个类实现了 Cloneable接口并重写了 Object类中的clone方法，就可以通过clone方法创建一个该类的实例的副本，也就是克隆对象。

注意事项

• 只有实现了 Cloneable 接口的类才能够被克隆，否则会抛出 CloneNotSupportedException 异常。
• Object类中的 clone方法是protected类型，并不能直接被其他类调用，需要在子类中重写 clone方法进行公开。
• 原生clone方法是浅拷贝。关于深浅拷贝的区别看后文图解说明。

1.2 优缺点

优点

• 可以避免重复创建对象，减少对象创建开销，提高程序性能。
• 简化对象的创建过程，隐藏对象的创建细节。
• clone方法基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。

缺点

• 在使用原型模式时，需要注意对成员变量中引用类型的处理，以避免浅拷贝带来的问题。
• 在需要深拷贝的情况下，实现起来比较复杂，特别是在对象的层次结构很深的情况下，需要各层级递归处理。

1.3 适用场景

原型模式在以下几种情况下比较适用：

• 当一个对象的创建过程非常复杂或者耗时时，可以通过复制一个已经创建好的实例来获得新的实例，从而提高性能。
• 当一个类的实例之间相互独立（状态不共享），且具有相同的结构时，可以使用原型模式简化创建过程。
• 当需要大量相同或相似对象时，使用原型模式避免重复创建对象。

1.4 Java Api中的原型案例

在Java API中，有很多类都使用了原型模式，以下是一些示例：

1. java.util.Date类
2. java.util.Calendar类
3. java.util.ArrayList类和java.util.LinkedList类
4. java.awt.geom.Area类

二、克隆人案例

接下来，我们通过一个克隆人的例子来看看如何在Java中实现原型模式，以及深克隆要如何实现

2.1 浅克隆实现

我们首先创建克隆人模型ClonePeople类，它拥有基本类型属性姓名、年龄，以及引用类型属性：身份证IdentityCard。在ClonePeople类中需要实现Cloneable接口并重写clone方法。

ClonePeople.java

public class ClonePeople implements Cloneable{
    private String name;
    private int age;
    //表示身份证的子对象
    private IdentityCard idCard;

    public ClonePeople(String name, int age, IdentityCard idCard) {
        this.name = name;
        this.age = age;
        this.idCard = idCard;
    }

    public void setIdCard(IdentityCard idCard) {
        this.idCard = idCard;
    }

    public IdentityCard getIdCard() {
        return idCard;
    }

    @Override
    public String toString() {
        return "我是克隆人[" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", idCard=" + idCard.getIdentityId() +
                ']';
    }

    @Override
    public Object clone() {
        ClonePeople clone = null;
        try {
            clone = (ClonePeople)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

IdentityCard.java

public class IdentityCard{
    private String identityId;//证件号

    public String getIdentityId() {
        return identityId;
    }

    public IdentityCard(String identityId) {
        this.identityId = identityId;

    }
}
1
2
3
4
5
6
7
8
9
10
11
12

测试浅克隆后对象和源对象关系

public class Client {
    public static void main(String[] args) {
        //创建原型对象ClonePeople
        IdentityCard idcard=new IdentityCard("1234567890");
        ClonePeople people=new ClonePeople("KangKang",12,idcard);
        //克隆
        ClonePeople anotherPeople = (ClonePeople)people.clone();
        System.out.println(anotherPeople.toString());
        //判断克隆对象地址是否相等
        System.out.println("克隆对象是否相等："+ (people==anotherPeople));
        //判断子对象地址是否相等
        System.out.println("子对象是否相等："+(people.getIdCard()==anotherPeople.getIdCard()));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试结果：

结论

根据测试结果可以得出：
1，克隆后的对象是一个新对象，其对象地址不一致，但是内容完全一致，这就是原型模式的魅力。
2，Object中的clone方法正是浅克隆，因为其子对象引用是同一个对象，内存地址是一致的。

2.2 深克隆实现

深克隆就是完全克隆，让子对象也重新创建，而不是引用同一个对象。这要如何实现呢？既然调用clone方法，可以让外部的对象重新创建，那我是不是也可以对子对象也调用clone方法呢。

步骤1：改造子对象，让子对象也实现Cloneable接口并重写clone方法

public class IdentityCard implements Cloneable{
    private String identityId;//证件号

    public String getIdentityId() {
        return identityId;
    }

    public IdentityCard(String identityId) {
        this.identityId = identityId;

    }

    @Override
    public Object clone() {
        IdentityCard clone = null;
        try {
            clone = (IdentityCard)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

步骤2：改造ClonePeople类中的clone方法，对子对象克隆后重新赋值

    @Override
    public Object clone() {
        ClonePeople clone = null;
        try {
            clone = (ClonePeople)super.clone();
            clone.setIdCard((IdentityCard)clone.getIdCard().clone());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
1
2
3
4
5
6
7
8
9
10
11

测试类不变，看测试结果。子对象是否相等为false，这说明子对象也重新创建了，而不是引用之前的对象。

结论

如果要实现深拷贝，不仅对象要重写clone方法，其各级子对象也要依次重写clone方法，而且需要对子对象重新设值，各层级递归处理，颇为麻烦。具体是否需要进行深拷贝，那就因地制宜了，视业务场景而定。

三、Java浅拷贝VS深拷贝

一个对象中属性类型可以分为基本数据类型和引用数据类型（或称子对象、属性对象），深浅拷贝的区别就在于子对象的拷贝上。

• 浅拷贝：对于对象中的引用类型，只拷贝其引用，新的引用仍然指向原来的子对象。

• 深拷贝：完全拷贝，对引用类型也开辟新的内存空间。

四、总结

经过上面的讲解，相信大家对Java原型模式有了更深入的了解。原型模式通过复制已有实例来创建新的实例，可以在一定程度上提高对象创建的效率。同时，原型模式适用于对象创建过程复杂、实例之间状态不共享且具有相同结构的场景。

在实际开发中，我们可以根据项目需求灵活运用原型模式，优化代码结构，提高代码的可读性和可维护性。当然，原型模式并不是万能的，我们还需要结合其他设计模式来解决实际问题。

希望本文能够帮助大家更好地理解和掌握原型模式。如果你觉得本文对你有所帮助，请不要吝啬你的点赞和分享，让更多的人受益！同时，欢迎大家在评论区留言交流，我们共同学习，共同进步！

---