• 设计模式之原型模式

    什么是原型模式？

    原型模式即使用已经创建的对象作为原型，通过复制该原型对象得到一个和原型完全相同的新对象。

    具体结构

    原型模式包含以下几种角色：

    1. 抽象原型类，规定了具体原型类必须实现的clone()方法；
    2. 具体原型类，实现了抽象原型类的clone()方法，表示此类可以被复制（克隆）；
    3. 访问类，使用具体原型类的clone()方法来创建新的对象。

    实现方法

    原型模式有两种实现方法，一种是浅拷贝，另外一种是深拷贝，也另有说法为浅克隆和深克隆。

    浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原

    有属性所指向的对象的内存地址。

    深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

    由上面的定义可知，浅拷贝对象中，非基本数据类型（对象类型）指向的是原有对象的内存地址，这样会导致修改其中一个对象的非基本数据类型时，另外的一个对象中的相关类型属性也会跟随改变。针对这一点需要特别注意。

    Java中使用Object类中native clone()方法来实现浅拷贝，使用方式是实现Cloneable接口，重写clone()方法,如果不重写方法，由于访问权限的问题，运行会报以下错误。

    java: clone() 在 java.lang.Object 中是 protected 访问控制

    如果不实现Cloneable接口，会报CloneNotSupportedException异常错误。

    所以必须重写clone()方法，修改访问修饰符为public，返回值为具体对象类型。

    浅拷贝

    以下为浅拷贝的实现代码

    1. public class MyPrototype implements Cloneable {//实现Cloneable接口
    2.  
    3.     public MyPrototype() {}
    4.  
    5.     // 需要重写clone方法
    6.     @Override
    7.     public MyPrototype clone() {
    8.         try {
    9.             return (MyPrototype) super.clone();
    10.         } catch (CloneNotSupportedException e) {
    11.             throw new AssertionError();
    12.         }
    13.     }
    14. }

    深拷贝

    深拷贝有两种实现方式，一是针对类内部的所有非基本数据类型（不包含String类型）的数据，让其实现Cloneable接口，重写其clone()方法。另外一种是使用序列化的方式，把对象先序列化，然后再反序列化回来就可以得到内存隔离的两个对象。这样修改各个对象的数据就能到达互补影响的效果

    以下为示例

    下面定义了Student和Teacher类，作为测试。

    1. //定义Student类
    2. public class Student implements Serializable {
    3.     private String studentName;
    4.     private int studentId;
    5.  
    6.     public Student(String studentName, int studentId) {
    7.         this.studentName = studentName;
    8.         this.studentId = studentId;
    9.     }
    10.  
    11.     public Student() {
    12.  
    13.     }
    14.  
    15.     public String getStudentName() {
    16.         return studentName;
    17.     }
    18.  
    19.     public void setStudentName(String studentName) {
    20.         this.studentName = studentName;
    21.     }
    22.  
    23.     public int getStudentId() {
    24.         return studentId;
    25.     }
    26.  
    27.     public void setStudentId(int studentId) {
    28.         this.studentId = studentId;
    29.     }
    30.  
    31.     @Override
    32.     public String toString() {
    33.         return "Student{" +
    34.                 "studentName='" + studentName + '\'' +
    35.                 ", studentId=" + studentId +
    36.                 '}';
    37.     }
    38. }
    39.  
    40. //定义Teacher类
    41. public class Teacher implements Cloneable, Serializable {
    42.     private String teacherName;
    43.     private int teacherId;
    44.     private List<Student> students;
    45.  
    46.     public Teacher() {
    47.     }
    48.  
    49.     public Teacher(String teacherName, int teacherId, List<Student> students) {
    50.         this.teacherName = teacherName;
    51.         this.teacherId = teacherId;
    52.         this.students = students;
    53.     }
    54.  
    55.     public String getTeacherName() {
    56.         return teacherName;
    57.     }
    58.  
    59.     public void setTeacherName(String teacherName) {
    60.         this.teacherName = teacherName;
    61.     }
    62.  
    63.     public int getTeacherId() {
    64.         return teacherId;
    65.     }
    66.  
    67.     public void setTeacherId(int teacherId) {
    68.         this.teacherId = teacherId;
    69.     }
    70.  
    71.     public List<Student> getStudents() {
    72.         return students;
    73.     }
    74.  
    75.     public void setStudents(List students) {
    76.         this.students = students;
    77.     }
    78.  
    79.     @Override
    80.     public String toString() {
    81.         return "Teacher{" +
    82.                 "teacherName='" + teacherName + '\'' +
    83.                 ", teacherId=" + teacherId +
    84.                 ", students=" + students +
    85.                 '}';
    86.     }
    87.  
    88.     @Override
    89.     public Teacher clone() {
    90.         try {
    91.             Teacher clone = (Teacher) super.clone();
    92.             return clone;
    93.         } catch (CloneNotSupportedException e) {
    94.             throw new AssertionError();
    95.         }
    96.     }
    97. }

    浅拷贝存在的问题，就是修改对象中的非基本数据类型，克隆的对象也会跟随改变，示例如下。

    1. public class PrototypeTest {
    2.  
    3.     public static void main(String[] args) {
    4.         Teacher teacher = new Teacher();
    5.         teacher.setTeacherName("李明");
    6.         teacher.setTeacherId(1001);
    7.  
    8.         List<Student> list = new ArrayList<>();
    9.         list.add(new Student("小红", 230001));
    10.         list.add(new Student("小亮", 230002));
    11.         teacher.setStudents(list);
    12.  
    13.         Teacher newTeacher = teacher.clone();
    14.         newTeacher.getStudents().get(0).setStudentName("小冰");
    15.         System.out.println(newTeacher);
    16.         System.out.println(teacher);
    17.     }
    18. }
    19. // 结果如下：
    20. // Teacher{teacherName='李明', teacherId=1001, 
    21. //students=[Student{studentName='小冰', studentId=230001}, 
    22. //Student{studentName='小亮', studentId=230002}]}
    23. // Teacher{teacherName='李明', teacherId=1001, 
    24. //students=[Student{studentName='小冰', studentId=230001}, 
    25. // Student{studentName='小亮', studentId=230002}]}
    26.  
    27.  
    28. // 测试结果显示，修改teacher对象后，newTeacher中的数据也一同发生了变化。
    29. // 这是因为Student数据指向了同一块内存区域。
    解决办法一

    一是使用序列化的方式，把对象先序列化，然后再反序列化回来就可以得到内存隔离的两个对象。这样修改各个对象的数据就能到达互补影响的效果。

    1. public class PrototypeTest {
    2.  
    3.     public static void main(String[] args) throws Exception {
    4.         Teacher teacher = new Teacher();
    5.         teacher.setTeacherName("李明");
    6.         teacher.setTeacherId(1001);
    7.  
    8.         List<Student> list = new ArrayList<>();
    9.         list.add(new Student("小红", 230001));
    10.         list.add(new Student("小亮", 230002));
    11.         teacher.setStudents(list);
    12.  
    13.         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("teacher.ob"));
    14.         objectOutputStream.writeObject(teacher);
    15.         objectOutputStream.close();
    16.  
    17.         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("teacher.ob"));
    18.         Teacher newTeacher1 = (Teacher) objectInputStream.readObject();
    19.         newTeacher1.getStudents().get(0).setStudentName("小梅");
    20.         teacher.getStudents().get(0).setStudentName("小美");
    21.         System.out.println(teacher);
    22.         System.out.println(newTeacher1);
    23.         System.out.println(teacher == newTeacher1);
    24.     }
    25. }
    26.  
    27. // 测试结果
    28. // Teacher{teacherName='李明', teacherId=1001, 
    29. // students=[Student{studentName='小美', studentId=230001}, 
    30. // Student{studentName='小亮', studentId=230002}]}
    31. // Teacher{teacherName='李明', teacherId=1001, 
    32. // students=[Student{studentName='小梅', studentId=230001}, 
    33. // Student{studentName='小亮', studentId=230002}]}

    可以看到，使用序列化和反序列化的方式后，得到的对象是内存隔离的，修改各个对象的数据互不影响。

    解决办法二

    针对类内部的所有非基本数据类型（不包含String类型）的数据，让其实现Cloneable接口，重写其clone()方法。

    所以需要让Student 类实现Cloneable接口，重写其clone方法。Teacher类也需要重写其clone方法，针对非基本类型也要调用clone方法，代码如下：

    1. public class Student implements Cloneable {
    2.     private String studentName;
    3.     private int studentId;
    4.  
    5.     public Student(String studentName, int studentId) {
    6.         this.studentName = studentName;
    7.         this.studentId = studentId;
    8.     }
    9.  
    10.     public Student() {
    11.  
    12.     }
    13.  
    14.     public String getStudentName() {
    15.         return studentName;
    16.     }
    17.  
    18.     public void setStudentName(String studentName) {
    19.         this.studentName = studentName;
    20.     }
    21.  
    22.     public int getStudentId() {
    23.         return studentId;
    24.     }
    25.  
    26.     public void setStudentId(int studentId) {
    27.         this.studentId = studentId;
    28.     }
    29.  
    30.     @Override
    31.     public String toString() {
    32.         return "Student{" +
    33.                 "studentName='" + studentName + '\'' +
    34.                 ", studentId=" + studentId +
    35.                 '}';
    36.     }
    37.  
    38.     @Override
    39.     public Student clone() {
    40.         try {
    41.             Student clone = (Student) super.clone();
    42.             return clone;
    43.         } catch (CloneNotSupportedException e) {
    44.             throw new AssertionError();
    45.         }
    46.     }
    47. }

    Teacher类clone方法重写

    1. package com.code.designpattern.prototype;
    2.  
    3. import java.io.Serializable;
    4. import java.util.ArrayList;
    5. import java.util.List;
    6.  
    7. public class Teacher implements Cloneable{
    8.     private String teacherName;
    9.     private int teacherId;
    10.     private List<Student> students;
    11.  
    12.     public Teacher() {
    13.     }
    14.  
    15.     public Teacher(String teacherName, int teacherId, List<Student> students) {
    16.         this.teacherName = teacherName;
    17.         this.teacherId = teacherId;
    18.         this.students = students;
    19.     }
    20.  
    21.     public String getTeacherName() {
    22.         return teacherName;
    23.     }
    24.  
    25.     public void setTeacherName(String teacherName) {
    26.         this.teacherName = teacherName;
    27.     }
    28.  
    29.     public int getTeacherId() {
    30.         return teacherId;
    31.     }
    32.  
    33.     public void setTeacherId(int teacherId) {
    34.         this.teacherId = teacherId;
    35.     }
    36.  
    37.     public List<Student> getStudents() {
    38.         return students;
    39.     }
    40.  
    41.     public void setStudents(List students) {
    42.         this.students = students;
    43.     }
    44.  
    45.     @Override
    46.     public String toString() {
    47.         return "Teacher{" +
    48.                 "teacherName='" + teacherName + '\'' +
    49.                 ", teacherId=" + teacherId +
    50.                 ", students=" + students +
    51.                 '}';
    52.     }
    53.  
    54.     @Override
    55.     public Teacher clone() {
    56.         try {
    57.         	// 重点在于改写这个clone方法，对非基本数据类型都需要调用clone方法重新赋值。
    58.             Teacher clone = (Teacher) super.clone();
    59.             List<Student> studentsList = clone.getStudents();
    60.             List<Student> studentsList2 = new ArrayList<>();
    61.             for (Student s:studentsList) {
    62.                 studentsList2.add(s.clone());
    63.             }
    64.             clone.setStudents(studentsList2);
    65.             return clone;
    66.         } catch (CloneNotSupportedException e) {
    67.             throw new AssertionError();
    68.         }
    69.     }
    70. }

    查看最终效果如下：

    1. public class PrototypeTest {
    2.  
    3.     public static void main(String[] args) throws Exception {
    4.         Teacher teacher = new Teacher();
    5.         teacher.setTeacherName("李明");
    6.         teacher.setTeacherId(1001);
    7.  
    8.         List<Student> list = new ArrayList<>();
    9.         list.add(new Student("小红", 230001));
    10.         list.add(new Student("小亮", 230002));
    11.         teacher.setStudents(list);
    12.  
    13.         Teacher newTeacher = teacher.clone();
    14.         newTeacher.getStudents().get(0).setStudentName("小冰");
    15.         System.out.println(newTeacher);
    16.         System.out.println(teacher);
    17.     }
    18. }
    19.  
    20. // 测试输出如下：
    21. //Teacher{teacherName='李明', teacherId=1001, 
    22. //students=[Student{studentName='小冰', studentId=230001}, 
    23. //Student{studentName='小亮', studentId=230002}]}
    24. //Teacher{teacherName='李明', teacherId=1001, 
    25. //students=[Student{studentName='小红', studentId=230001}, 
    26. //Student{studentName='小亮', studentId=230002}]}
    总结：

    一般推荐使用序列化的方法进行深拷贝，实现Cloneable接口重写clone方法的方式有些繁琐。

  • 相关阅读:
    【毕业设计】机器视觉答题卡识别系统 - python 深度学习
    助力工业物联网，工业大数据之服务域：可视化工具Grafana介绍【三十八】
    【Java】认识类和对象
    java 前后端开发 常用下载链接
    ESPHome不经过HA设备1直接控制设备2
    【Unity】Xml的加密读取保存
    2022 年辽宁省大学生程序设计竞赛 个人题解
    Android应用集成RabbitMQ消息处理指南
    .NET C#版本和.NET版本以及VS版本的对应关系
    考虑温度影响的vumat子程序在木材受火后强度分析中的应用
  • 原文地址：https://blog.csdn.net/qq_24054661/article/details/133889633