介绍

  1. 原型模式(Prototype模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
  2. 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
  3. 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone()

个人总结
如果需要多个相同的定制化对象时（除了对象内存地址不一样），并不需要多次以相同方法创建，这个操作复杂，只需要调用对象.clone（）克隆一个这样的对象即可

浅拷贝

  1. //一个person类实现Cloneable接口的clone方法
  2. //person具有两个基本数据类型的属性name age和一个引用类型的属性address
  3. public class Person implements Cloneable{
  4.     String name;
  5.     int age;
  6.     Address address;
  8.     public Person(String name, int age, Address address) {
  9.         this.name = name;
  10.         this.age = age;
  11.         this.address = address;
  12.     }
  14.     @Override
  15.     public String toString() {
  16.         return "Person{" +
  17.                 "name='" + name + '\'' +
  18.                 ", age=" + age +
  19.                 ", address=" + address +
  20.                 '}';
  21.     }
  23.     @Override
  24.     protected Object clone() throws CloneNotSupportedException {
  25.         return super.clone();
  26.     }
  27. }
  29. //Address类
  30. public class Address {
  31.     String city;
  32.     String street;
  33.     int emailNum;
  35.     public Address(String city, String street, int emailNum) {
  36.         this.city = city;
  37.         this.street = street;
  38.         this.emailNum = emailNum;
  39.     }
  40. }
  42. //测试
  43. public class test {
  44.     public static void main(String[] args) throws Exception {
  45.         Address addr = new Address("广州市", "青云街", 40033);
  46.         Person p1 = new Person("小明", 18, addr);
  47.         Person p2 = (Person)p1.clone();
  49.         System.out.println(p1);
  50.         System.out.println(p2);
  51.         System.out.println("p1对象---------->"+p1.hashCode());
  52.         System.out.println("p2对象---------->"+p2.hashCode());
  53.         System.out.println("p1的地址---------->"+p1.address.hashCode());
  54.         System.out.println("p2的地址---------->"+p2.address.hashCode());
  55.     }
  56. }

测试输出控制台结果：
可以看出虽然使用p1为模板克隆出了一个p2，但是p1和p2的引用属性address并没有真正的克隆，他们只是指向了一个相同的address对象image-20200925194552886.png

深拷贝（重写clone方法）

  1. //一个person类实现Cloneable接口的clone方法
  2. //person具有两个基本数据类型的属性name age和一个引用类型的属性address
  3. //实现深拷贝需要重写clone方法
  4. public class Person implements Cloneable{
  5.     String name;
  6.     int age;
  7.     Address address;
  9.     public Person(String name, int age, Address address) {
  10.         this.name = name;
  11.         this.age = age;
  12.         this.address = address;
  13.     }
  15.     @Override
  16.     public String toString() {
  17.         return "Person{" +
  18.                 "name='" + name + '\'' +
  19.                 ", age=" + age +
  20.                 ", address=" + address +
  21.                 '}';
  22.     }
  24.     @Override
  25.     protected Object clone() throws CloneNotSupportedException {
  26.         Object obj = super.clone();     //首先把基本数据类型的属性克隆一次
  27.         Person person = (Person)obj;
  28.         person.address=(Address) address.clone(); //在把引用类型的基本数据类型复制一次
  29.         return person;
  30.     }
  31. }
  33. //Address类需要实现Cloneable的clone方法
  34. public class Address implements Cloneable{
  35.     String city;
  36.     String street;
  37.     int emailNum;
  39.     public Address(String city, String street, int emailNum) {
  40.         this.city = city;
  41.         this.street = street;
  42.         this.emailNum = emailNum;
  43.     }
  45.     @Override
  46.     protected Object clone() throws CloneNotSupportedException {
  47.         return super.clone();
  48.     }
  49. }
  51. //测试
  52. public class test {
  53.     public static void main(String[] args) throws Exception {
  54.         Address addr = new Address("广州市", "青云街", 40033);
  55.         Person p1 = new Person("小明", 18, addr);
  56.         Person p2 = (Person)p1.clone();
  58.         System.out.println(p1);
  59.         System.out.println(p2);
  60.         System.out.println("p1对象---------->"+p1.hashCode());
  61.         System.out.println("p2对象---------->"+p2.hashCode());
  62.         System.out.println("p1的地址---------->"+p1.address.hashCode());
  63.         System.out.println("p2的地址---------->"+p2.address.hashCode());
  64.     }
  65. }

测试输出控制台结果：
可以看出p1作为模板克隆出了p2，而且p1和p2中的引用属性address也真正克隆出了一份image-20200925195918647.png

深拷贝(序列化)推荐使用

  1. //person类实现序列化接口
  2. //创建一个序列化克隆的方法getclone实现深克隆
  3. public class Person implements Serializable {
  4.     String name;
  5.     int age;
  6.     Address address;
  8.     public Person(String name, int age, Address address) {
  9.         this.name = name;
  10.         this.age = age;
  11.         this.address = address;
  12.     }
  14.     @Override
  15.     public String toString() {
  16.         return "Person{" +
  17.                 "name='" + name + '\'' +
  18.                 ", age=" + age +
  19.                 ", address=" + address +
  20.                 '}';
  21.     }
  23.     public Person getClone(){
  24.         ByteArrayOutputStream   bos = null;
  25.         ObjectOutputStream oos = null;
  26.         ByteArrayInputStream bis = null;
  27.         ObjectInputStream ois = null;
  28.         try {
  29.             //序列化
  30.             bos = new ByteArrayOutputStream();        //创建一个byte数组缓冲区
  31.             oos = new ObjectOutputStream(bos);        //把byte缓冲区和对象对接上
  32.             oos.writeObject(this);                    //把对象写进byte缓冲区
  34.             //反序列化
  35.             bis = new ByteArrayInputStream(bos.toByteArray());  //把缓冲区的对象放进新的byte数组中
  36.             ois = new ObjectInputStream(bis);        //把对象数组进过对象输入流处理成对象
  37.             //返回生成的新对象
  38.            Person person = (Person) ois.readObject();
  39.            return person;
  40.         } catch (Exception e) {
  41.             e.printStackTrace();
  42.             return null;
  43.         }finally {
  44.             try {
  45.                 ois.close();    
  46.                 oos.close();          
  47.             }catch (Exception e){
  48.                 e.printStackTrace();
  49.             }
  52.         }
  53.     }
  55. }
  57. //Address类实现序列化接口
  58. public class Address implements Serializable {
  59.     String city;
  60.     String street;
  61.     int emailNum;
  63.     public Address(String city, String street, int emailNum) {
  64.         this.city = city;
  65.         this.street = street;
  66.         this.emailNum = emailNum;
  67.     }
  69. }
  71. //测试
  72. public class test {
  73.     public static void main(String[] args) throws Exception {
  74.         Address addr = new Address("广州市", "青云街", 40033);
  75.         Person p1 = new Person("小明", 18, addr);
  76.         Person p2 = p1.getClone();
  77.         System.out.println("p1---------------->"+p1);
  78.         System.out.println("p2---------------->"+p2);
  79.         System.out.println("p1哈希值---------------->"+p1.hashCode());
  80.         System.out.println("p2哈希值---------------->"+p2.hashCode());
  81.         System.out.println("p1的地址---------------->"+p1.address.hashCode());
  82.         System.out.println("p2的地址---------------->"+p2.address.hashCode());
  83.     }
  84. }

测试输出控制台结果：
p1通过序列化克隆的方法把p2克隆出来image-20200925205035594.png

深拷贝基本介绍

  1. 复制对象的所有基本数据类型的成员变量值
  2. 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝
  3. 深拷贝实现方式1：重写clone方法来实现深拷贝：

缺点： 当对象中有很多成员对象，且成员对象中又有成员对象时，使用clone的方式，需要在每个引用到的成员对象所在的类中重写clone方法，非常的麻烦。

  1. 深拷贝实现方式2：通过对象序列化实现深拷贝(推荐)：

优点：序列化的方式，值需要在引用到的对象所在类实现Serializable接口，在写一个共用的复制对象的处理方法就行了，更加方便灵活。这是推荐的方式。

原型模式的注意事项和细节

  1. 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
  2. 不用重新初始化对象，而是动态地获得对象运行时的状态
  3. 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
  4. 在实现深克隆的时候可能需要比较复杂的代码
  5. 缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则，这点请同学们注意.