一、实质
- 通过
new产生一个对象有时需要非常频繁的数组准备或访问权限，则可以使用原型模式。就是java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点。 - 优势：效率高（直接克隆，避免了重新执行构造过程步骤）
- 克隆类似于
new，但是不同于new。new创建新的对象属性采用的是默认值。克隆出的对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后，再修改克隆对象的值。
二、原型模式的实现
- 实现
Cloneable接口和覆写clone方法 -
Prototype模式中实现起来最困难的地方就是内存复制操作，所幸在java中提供了clone()方法替我们做了绝大部分事情。
三、应用场景
spring中bean的创建实际就两种：单例模式和原型模式（当然原型模式需要和工厂模式搭配起来）
Sheep.java
package cn.itcast.day233.prototype;
import java.util.Date;
//克隆羊多利，实现Cloneable接口，此接口是一个空接口
public class Sheep implements Cloneable {
private String name;
private Date birthday;
public Sheep() {
}
public Sheep(String name, Date birthday) {
this.name = name;
this.birthday = birthday;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone();//直接使用父类的克隆方法
//添加如下代码实现深复制
Sheep s = (Sheep) obj;
s.birthday = (Date) this.birthday.clone();//将属性中的对象（非基本数据类型）也进行拷贝
return obj;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
说明：上面我们给出了浅克隆和深克隆的两种情况，下面进行测试。
Client.java
package cn.itcast.day233.prototype;
import java.util.Date;
//测试原型模式（浅克隆或者深克隆，两者有一些区别）
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Date date = new Date(1241341651L);
Sheep s1 = new Sheep("多利", date);
System.out.println(s1);
System.out.println(s1.getName() + "," + s1.getBirthday());
//通过s1克隆一个对象，可以看到这是两个不同的对象，但是它们属性的值是相同的，我们可以自己修改
Sheep s2 = (Sheep) s1.clone();
System.out.println(s2);
System.out.println(s2.getName() + "," + s2.getBirthday());
date.setTime(44444444L);
//下面在浅克隆的情况下输出为：Thu Jan 01 20:20:44 CST 1970,Thu Jan 01 20:20:44 CST 1970
//在深克隆的情况下输出为：Thu Jan 01 20:20:44 CST 1970,Thu Jan 15 16:49:01 CST 1970
System.out.println(s1.getBirthday() + "," + s2.getBirthday());
}
}
说明：当一个对象中的属性有其他对象类型时，浅克隆和深克隆就会表现出区别。在测试例子中我们可以看到当改变第一个对象的日期属性的时候，如果是浅复制，那么原对象和克隆对象的日期属性都会发生改变，而如果是深复制，那么只会影响原对象，而不会影响克隆对象。上面是通过克隆的方式来达到复制的目的的，下面我们看通过序列化和反序列化实现对象的复制。
Sheep1.java
package cn.itcast.day233.prototype;
import java.io.Serializable;
import java.util.Date;
//克隆羊多利，实现Cloneable接口，此接口是一个空接口
public class Sheep1 implements Cloneable, Serializable {
private String name;
private Date birthday;
public Sheep1() {
}
public Sheep1(String name, Date birthday) {
this.name = name;
this.birthday = birthday;
}
//此类自己本身没有实现深克隆
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone();//直接使用父类的克隆方法
return obj;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
说明：上述对象本身并没有实现深复制，下面我们通过序列化和反序列化实现深复制。
Client1.java
package cn.itcast.day233.prototype;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;
//利用序列化和反序列化技术实现深克隆
public class Client1 {
public static void main(String[] args) throws Exception {
Date date = new Date(1241341651L);
Sheep1 s1 = new Sheep1("多利", date);
System.out.println(s1.getName() + "," + s1.getBirthday());
//使用序列化和反序列化实现
//序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(s1);
byte[] bytes = bos.toByteArray();
//反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
Sheep1 s2 = (Sheep1) ois.readObject();
System.out.println(s2.getName() + "," + s2.getBirthday());
date.setTime(44444444L);
System.out.println(s1.getBirthday() + "," + s2.getBirthday());
}
}
说明：可以看到和之前的深复制的测试结果是一致的。下面我们测试比较new和克隆的效率。
Client2.java
package cn.itcast.day233.prototype;
//测试克隆比new的效率高
public class Client2 {
public static void testNew(int size){
long start = System.currentTimeMillis();
for(int i = 0; i < size; i++){
Laptop t = new Laptop();
}
long end = System.currentTimeMillis();
System.out.println("new耗时" + (end - start));
}
public static void testClone(int size) throws Exception{
long start = System.currentTimeMillis();
Laptop t = new Laptop();
Laptop[] arr = new Laptop[size];
for(int i = 0; i < size; i++){
arr[i] = (Laptop) t.clone();
}
long end = System.currentTimeMillis();
System.out.println("clone耗时" + (end - start));
}
public static void main(String[] args) throws Exception {
testClone(1000);
testNew(1000);
}
}
class Laptop implements Cloneable{
public Laptop(){
try {
Thread.sleep(10);//假设一个笔记本对象的创建过程很耗时
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
说明：测试结果为：
clone耗时12
new耗时10483
可以看到差距非常明显，当然这只是在构造一个对象非常耗时的情况下的结果，如果一个类本身构造就很便捷，那么就不必使用原型模式了。
