原型模式
原型模式（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<String> ArrayList;
public List<String> getArrayList() {
return ArrayList;
}
public void setArrayList(List<String> 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<String>());
//浅克隆对象
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<String> ArrayList; public List<String> getArrayList() { return ArrayList; } public void setArrayList(List<String> 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<String>()); //浅克隆对象 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
可以看到，上面的序列化方法是可以实现对象深克隆的目的
