原型模式

原型模式

原型模式（Prototype Pattern）是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

这里需要引入两个概念：

• 浅克隆

  浅克隆. 它的工作原理如下: 在内存中先开辟一块和原始对象相同的空间, 然后复制原始对象的内容. 对于基本数据类型, 这样操作当然没问题, 但对于引用类型, 由于保存的仅仅是对象的引用, 克隆过去的引用所指向的是同一个对象.

• 深克隆

  深克隆是指对原型对象中的引用类型采用递归的方式进行值复制，在堆内重新创建了一个新的对象，与原型对象中的成员变量值一样，但是在栈内的地址不一样。

赋值

---

//实体类
public class Student {  
    private int number;  
  
    public int getNumber() {  
        return number;  
    }    
    public void setNumber(int number) {  
        this.number = number;  
    }        
}  
//测试
public class Test {  
    public static void main(String args[]) {  
        Student stu1 = new Student();  
        stu1.setNumber(123445);  
        Student stu2 = stu1;  
          
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
    }  
}

结果：

学生1:123445
学生2:123445

对象=对象的赋值，指向内存堆中的同一个对象

浅克隆

实现Cloneable接口并重写Object类中的clone()方法

//实体类 实现Cloneable接口并重写Object类中的clone()方法

public class Student implements Cloneable{
    private int age;

    private List ArrayList;

    public List getArrayList() {
        return ArrayList;
    }

    public void setArrayList(List arrayList) {
        ArrayList = arrayList;
    }

    public int getAge() {
        return age;
    }

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

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

//测试类
public class StudentTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        //原型对象
        Student student = new Student();
        student.setAge(18);
        student.setArrayList(new ArrayList());
        //浅克隆对象
        Student student1 = (Student) student.clone();

        System.out.println(student.getAge()==student1.getAge());
        System.out.println(student.getArrayList()==student1.getArrayList());
        System.out.println(student==student1);

    }
}

结果

true
true 说明list只是复制了地址，并非独立的对象
false

深克隆

一般采取两种方法

• 在引用变量较少的情况下，可以对每个引用变量本身实现Cloneable接口，并实现clone()方法，缺点也很明显，略微复杂一点的实体类，这样做会导致代码量激增。（执行效率高）

• 使用序列化

  实现Serializable接口用于序列化（执行效率低）

  将对象先序列化存储到流中，然后再从流中反序列化读出对象，这样就可以保证读取出来的数据和之前的对象，里面的值完全相同，就像是一个完全的拷贝，但是相当于重新new了一个，因为堆内存给分配了新的地址

  //实现Serializable接口用于序列化
  public class Student implements Serializable {
      private int age;
  
      private List ArrayList;
  
      public List getArrayList() {
          return ArrayList;
      }
  
      public void setArrayList(List arrayList) {
          ArrayList = arrayList;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          this.age = age;
      }
  
      @Override
      protected Object clone() throws CloneNotSupportedException {
          try{
              //内存中完成操作，直接在内存中完成操作
              //将对象的字节码写入内存
              ByteArrayOutputStream bos = new ByteArrayOutputStream();
              ObjectOutputStream oos = new ObjectOutputStream(bos);
              oos.writeObject(this);
  
              //从内存中读取字节码，重新创建一个新的对象，地址不同
              ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
              ObjectInputStream ois = new ObjectInputStream(bis);
  
              Student copy = (Student)ois.readObject();
              return copy;
          }catch (Exception e){
              e.printStackTrace();
          }
          return null;
      }
  }
  
  

  public class StudentTest {
      public static void main(String[] args) throws CloneNotSupportedException {
          //原型对象
          Student student = new Student();
          student.setAge(18);
          student.setArrayList(new ArrayList());
          //浅克隆对象
          Student student1 = (Student) student.clone();
  
          System.out.println(student.getAge()==student1.getAge());
          System.out.println(student.getArrayList()==student1.getArrayList());
          System.out.println(student==student1);
      }
  }
  

结果

true
false
false

可以看到，上面的序列化方法是可以实现对象深克隆的目的