我们在创建对象时，通常是通过new关键字来创建的。但是，思考一下，如果当前类的构造函数很复杂，每次new对象时都会消耗非常多的资源，这样肯定是不行的，耗时又费力。

那有没有什么办法解决这种问题呢？当然有，原型模式就可以解决这个痛点。

原型模式非常好理解，就是类的实例对象可以克隆自身，产生新的实例对象，这样就无需用new来创建。想一下，齐天大圣孙悟空是不是拔一根汗毛，就复制出了很多个一模一样的孙悟空，道理是一样的。（新的对象和原对象，内容相同，但是内存地址不同，因为是不同的对象。）

那在Java中，我们怎么实现原型模式呢？非常简单，只需要原型对象实现Cloneable接口就可以了，看代码：（学生对象的复制，学生对象中包含他所学的学科类的对象）

  1. //学科类
  2. public class Subject {
  3.     private String name;
  4.     private String content;
  6.     public String getName() {
  7.         return name;
  8.     }
  10.     public Subject setName(String name) {
  11.         this.name = name;
  12.         return this;
  13.     }
  15.     public String getContent() {
  16.         return content;
  17.     }
  19.     public Subject setContent(String content) {
  20.         this.content = content;
  21.         return this;
  22.     }
  24.     public Subject(String name, String content) {
  25.         this.name = name;
  26.         this.content = content;
  27.     }
  29.     public Subject() {
  30.     }
  32.     @Override
  33.     public String toString() {
  34.         return "Subject{" +
  35.                 "name='" + name + '\'' +
  36.                 ", content='" + content + '\'' +
  37.                 '}';
  38.     }
  39. }
  40. //学生类
  41. public class Student implements Cloneable {
  42.     private int age;
  43.     private String name;
  44.     private Subject subject;
  46.     public int getAge() {
  47.         return age;
  48.     }
  50.     public void setAge(int age) {
  51.         this.age = age;
  52.     }
  54.     public String getName() {
  55.         return name;
  56.     }
  58.     public void setName(String name) {
  59.         this.name = name;
  60.     }
  62.     public Subject getSubject() {
  63.         return subject;
  64.     }
  66.     public void setSubject(Subject subject) {
  67.         this.subject = subject;
  68.     }
  70.     public Student(int age, String name, Subject subject) {
  71.         this.age = age;
  72.         this.name = name;
  73.         this.subject = subject;
  74.     }
  76.     public Student() {
  77.     }
  79.     @Override
  80.     public String toString() {
  81.         return "Student{" +
  82.                 "age=" + age +
  83.                 ", name='" + name + '\'' +
  84.                 ", subject=" + subject +
  85.                 '}';
  86.     }
  88.     @Override
  89.     protected Object clone() throws CloneNotSupportedException {
  90.         //实现Cloneable接口，调用父类Object的clone方法来实现对象的拷贝
  91.         return super.clone();
  92.     }
  93. }
  94. public class ProTest {
  95.     public static void main(String[] args) throws Exception {
  96.         Student s1 = new Student(18,"张三",new Subject("语文","这是语文书"));
  97.         //通过调用s1对象的clone方法，即可创建一个新的对象s2
  98.         Student s2 = (Student)s1.clone();
  100.         System.out.println(s1);
  101.         System.out.println(s2);
  103.         s2.setAge(20);
  104.         s2.setName("李四");
  105.         s2.getSubject().setName("数学").setContent("这是数学书");
  107.         System.out.println("=======");
  108.         System.out.println(s1);
  109.         System.out.println(s2);
  111.     }
  112. }

打印结果如下：

  1. Student{age=18, name='张三', subject=Subject{name='语文', content='这是语文书'}}
  2. Student{age=18, name='张三', subject=Subject{name='语文', content='这是语文书'}}
  3. ========
  4. Student{age=18, name='张三', subject=Subject{name='数学', content='这是数学书'}}
  5. Student{age=20, name='李四', subject=Subject{name='数学', content='这是数学书'}}

可以发现，s2对象修改的年龄和姓名对原对象s1没有任何影响，但是subject对象修改之后，原对象s1中的subject对象内容也被更改了，这是怎么回事呢？其实，这是因为我们使用的是浅拷贝。（Object对象的clone方法本身就是浅拷贝）

浅拷贝：对值类型的成员变量进行值的复制，对引用类型的成员变量只进行引用的复制，而不复制引用所指向的对象。（嗯？这句话怎么听起来这么熟悉，看下这个：为什么大家都说Java中只有值传递）此时，新对象里边的引用类型变量相当于原对象的引用类型变量的副本，他们指向的是同一个对象。

因此，修改了s2对象的subject对象的内容，原对象s1的subject对象内容也会跟着改变。那如果，我不想让原对象的引用类型变量内容发生改变，应该怎么做呢？

这就要用到深拷贝了，即把引用类型变量的内容也拷贝一份，这样他们就互不影响了。一般有两种方式来实现深拷贝：一种是让需要拷贝的引用类型也实现Cloneable接口，然后重写clone方法；另一种是利用序列化。

clone方式：

还是以上边的例子来说。首先需要修改Subject类让它实现Cloneable接口，重写clone方法。然后修改Student类的clone方法，把所有引用类型的变量手动拷贝一下。

  1. public class Subject implements Cloneable{
  2.     private String name;
  3.     private String content;
  5.     public String getName() {
  6.         return name;
  7.     }
  9.     public Subject setName(String name) {
  10.         this.name = name;
  11.         return this;
  12.     }
  14.     public String getContent() {
  15.         return content;
  16.     }
  18.     public Subject setContent(String content) {
  19.         this.content = content;
  20.         return this;
  21.     }
  23.     public Subject(String name, String content) {
  24.         this.name = name;
  25.         this.content = content;
  26.     }
  28.     public Subject() {
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Subject{" +
  34.                 "name='" + name + '\'' +
  35.                 ", content='" + content + '\'' +
  36.                 '}';
  37.     }
  39.     @Override
  40.     protected Object clone() throws CloneNotSupportedException {
  41.         return super.clone();
  42.     }
  43. }
  45. public class Student implements Cloneable {
  46.     private int age;
  47.     private String name;
  48.     private Subject subject;
  50.     public int getAge() {
  51.         return age;
  52.     }
  54.     public void setAge(int age) {
  55.         this.age = age;
  56.     }
  58.     public String getName() {
  59.         return name;
  60.     }
  62.     public void setName(String name) {
  63.         this.name = name;
  64.     }
  66.     public Subject getSubject() {
  67.         return subject;
  68.     }
  70.     public void setSubject(Subject subject) {
  71.         this.subject = subject;
  72.     }
  74.     public Student(int age, String name, Subject subject) {
  75.         this.age = age;
  76.         this.name = name;
  77.         this.subject = subject;
  78.     }
  80.     public Student() {
  81.     }
  83.     @Override
  84.     public String toString() {
  85.         return "Student{" +
  86.                 "age=" + age +
  87.                 ", name='" + name + '\'' +
  88.                 ", subject=" + subject +
  89.                 '}';
  90.     }
  92.     @Override
  93.     protected Object clone() throws CloneNotSupportedException {
  94.         Student cloneStu = (Student)super.clone();
  95.         //手动拷贝subject对象，然后赋值给student克隆的新对象
  96.         cloneStu.setSubject((Subject) this.subject.clone());
  97.         return cloneStu;
  98.     }
  99. }

再次运行测试类，会发现修改新对象的引用类型变量已经无法影响原对象的引用类型变量了。

  1. Student{age=18, name='张三', subject=Subject{name='语文', content='这是语文书'}}
  2. Student{age=18, name='张三', subject=Subject{name='语文', content='这是语文书'}}
  3. ========
  4. Student{age=18, name='张三', subject=Subject{name='语文', content='这是语文书'}}
  5. Student{age=20, name='李四', subject=Subject{name='数学', content='这是数学书'}}

序列化方式

可以发现，用clone的方式实现起来是非常简单的。但是，考虑如果对象中的引用类型变量很多的时候，这种方式就不太方便 了，因为你要把所有的引用类型都手动clone一遍。另外，如果引用类型又嵌套了多层引用类型，那将是一场灾难。这时，就可以考虑用序列化方式。

系列化方式是通过把对象序列化成二进制流，放到内存中，然后再反序列化成为新的Java对象，这样就可以保证新对象和原对象的互相独立了。

这种方式，需要所有类都实现Serializable接口。Student类只需要添加一个系列化和反序列化的方法就可以了。

  1. public class Subject implements Serializable {
  2.     private String name;
  3.     private String content;
  5.     public String getName() {
  6.         return name;
  7.     }
  9.     public Subject setName(String name) {
  10.         this.name = name;
  11.         return this;
  12.     }
  14.     public String getContent() {
  15.         return content;
  16.     }
  18.     public Subject setContent(String content) {
  19.         this.content = content;
  20.         return this;
  21.     }
  23.     public Subject(String name, String content) {
  24.         this.name = name;
  25.         this.content = content;
  26.     }
  28.     public Subject() {
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Subject{" +
  34.                 "name='" + name + '\'' +
  35.                 ", content='" + content + '\'' +
  36.                 '}';
  37.     }
  38. }
  39. public class Student implements Serializable {
  40.     private int age;
  41.     private String name;
  42.     private Subject subject;
  44.     public int getAge() {
  45.         return age;
  46.     }
  48.     public void setAge(int age) {
  49.         this.age = age;
  50.     }
  52.     public String getName() {
  53.         return name;
  54.     }
  56.     public void setName(String name) {
  57.         this.name = name;
  58.     }
  60.     public Subject getSubject() {
  61.         return subject;
  62.     }
  64.     public void setSubject(Subject subject) {
  65.         this.subject = subject;
  66.     }
  68.     public Student(int age, String name, Subject subject) {
  69.         this.age = age;
  70.         this.name = name;
  71.         this.subject = subject;
  72.     }
  74.     public Student() {
  75.     }
  77.     @Override
  78.     public String toString() {
  79.         return "Student{" +
  80.                 "age=" + age +
  81.                 ", name='" + name + '\'' +
  82.                 ", subject=" + subject +
  83.                 '}';
  84.     }
  87.     //深克隆
  88.     public Object deepClone() throws IOException, ClassNotFoundException{
  89.         //把对象写入到流中
  90.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
  91.         ObjectOutputStream oos = new ObjectOutputStream(bos);
  92.         oos.writeObject(this);
  93.         //从流中读取
  94.         ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
  95.         ObjectInputStream ois = new ObjectInputStream(bis);
  96.         return ois.readObject();
  97.     }
  98. }
  99. public class ProTest {
  100.     public static void main(String[] args) throws Exception {
  101.         Student s1 = new Student(18,"张三",new Subject("语文","这是语文书"));
  102.         Student s2 = (Student)s1.deepClone();
  104.         System.out.println(s1);
  105.         System.out.println(s2);
  107.         s2.setAge(20);
  108.         s2.setName("李四");
  109.         s2.getSubject().setName("数学").setContent("这是数学书");
  111.         System.out.println("========");
  112.         System.out.println(s1);
  113.         System.out.println(s2);
  115.     }
  116. }

可以看到，在测试类中通过调用deepClone自定义的深克隆方法即可。这种方式适合引用类型或者子嵌套特别多的情况，每个类只需要实现Serializable接口即可，Student的deepClone方法也不需要再改动。

需要注意，这种方式的深拷贝，类中引用类型变量不能用 transient 修饰。（不懂的，自行搜索transient关键字，简单说就是用transient修饰的变量默认不会被序列化）

版权声明：本文为starry-skys原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/starry-skys/p/12208752.html