原型模式
原型模式(克隆模式/拷贝模式)
-通过new产生一个独享需要非常繁琐的数据准备或访问权限,则可以使用原型模式。
-就是java中的克隆技术,以某个对象为原型,复制出新的对象。显然,新的对象具备原型对象的特点。
-优势有:效率高(直接克隆,避免了重新执行构造过程步骤)
-克隆类似与new,但是不同于new。new撞见新的对象属性采用的是默认值。克隆出对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后,在修改克隆对象的值、
注意:克隆和拷贝是一回事!!
原型模式实现
-Cloneable接口和clone方法
-Prototype模式中实现起来最困难的地方就是内存复制操作,所幸Java中提供了clone()方法替我们做了绝大部分事情
原型模式(浅克隆)
浅克隆:被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。
package Prototype;
import java.util.Date;
public class Sheep implements Cloneable { //1997 英国 克隆羊 多利
private String sname;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone(); //直接调用object独享的clone()方法
return obj;
}
public Sheep() {
}
public Sheep(String sname, Date birthday) {
super();
this.sname = sname;
this.birthday = birthday;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
package Prototype;
import java.util.Date;
/**
* 测试原型模式(浅克隆)
* @author ly
*
*/
public class Cient {
public static void main(String[] args) throws Exception {
Date date = new Date(123554546L);
Sheep s1 = new Sheep("多利",date);
Sheep s2 = (Sheep) s1.clone();//克隆
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
date.setTime(554561656L);//修改时间对象的值
System.out.println(s1.getBirthday());
//克隆对象与原型对象保持一样的值 可以修改其中的值
s2.setSname("多多利");
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
浅克隆模式存在的问题
– 被复制的对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用都
仍然指向原来的对象。
原型模式(深克隆)
深克隆:被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换言之,深复制把要复制的对象所引用的对象都复制了一遍。
– 深克隆把引用的变量指向复制过的新对象,而不是原有的被引用的对象。
– 深克隆:让已实现Clonable接口的类中的属性也实现Clonable接口
– 基本数据类型和String能够自动实现深度克隆(值的复制)
原型模式(深克隆实现方式一)
package Prototype;
import java.util.Date;
public class Sheep2 implements Cloneable { //1997 英国 克隆羊 多利
private String sname;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone(); //直接调用object独享的clone()方法
//添加如下代码实现深复制(deep Clone)
Sheep2 s = (Sheep2) obj;
s.birthday = (Date) this.birthday.clone();//把属性也进行克隆
return obj;
}
public Sheep2() {
}
public Sheep2(String sname, Date birthday) {
super();
this.sname = sname;
this.birthday = birthday;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
package Prototype;
import java.util.Date;
/**
* 原型模式(深复制)
* @author ly
*
*/
public class Client2 {
public static void main(String[] args) throws Exception {
Date date = new Date(123554546L);
Sheep2 s1 = new Sheep2("多利",date);
Sheep2 s2 = (Sheep2) s1.clone();//实现深复制 s2对象的birthday是一个新的对象
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
date.setTime(554561656L);
System.out.println(s1.getBirthday());
//克隆对象与原型对象保持一样的值 可以修改其中的值
s2.setSname("多多利");
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
原型模式(深克隆实现方式二)
-通过序列化和反序列化实现深复制
package Prototype;
import java.io.Serializable;
import java.util.Date;
public class Sheep implements Cloneable,Serializable{ //1997 英国 克隆羊 多利
private String sname;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone(); //直接调用object独享的clone()方法
return obj;
}
public Sheep() {
}
public Sheep(String sname, Date birthday) {
super();
this.sname = sname;
this.birthday = birthday;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
package Prototype;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;
/**
* 原型模式(深复制,使用序列化和反序列化实现深复制)
* @author ly
*
*/
public class Client3 {
public static void main(String[] args) throws Exception {
Date date = new Date(123554546L);
Sheep s1 = new Sheep("多利",date);
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
// Sheep s2 = (Sheep) s1.clone();
//使用序列化和反序列化实现深复制
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);
Sheep s2 = (Sheep) ois.readObject();//克隆好的对象
System.out.println("修改原型对象属性值");
date.setTime(55456551656L);
System.out.println(s1.getBirthday());
//克隆对象与原型对象保持一样的值 可以修改其中的值
s2.setSname("多多利");
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
new方式创建对象与clone方式创建对象比较
package Prototype;
/**
* 测试普通new方式创建对象和clone方式创建对象的效率差异!
* 如果需要短时间创建大量对象,并且new的过程比较耗时,则可以考虑使用原型模式!!
* @author ly
*
*/
public class Client4 {
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 CloneNotSupportedException {
long start = System.currentTimeMillis();
Laptop t = new Laptop();
for(int i=0;i<size;i++){
Laptop temp = (Laptop) t.clone();
}
long end = System.currentTimeMillis();
System.out.println("clone的方式创建耗时"+(end-start));
}
public static void main(String[] args) throws CloneNotSupportedException {
testNew(1000);//19531
testClone(1000);//11
// System.exit(0);
}
}
class Laptop implements Cloneable{ //笔记本电脑
public Laptop() {
try {
Thread.sleep(10);//模拟创建对象耗时的过程
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
}```