package basic;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public abstract class PrototypeBasic<T> implements Cloneable, Serializable {
/**
*
*/
private static final long serialVersionUID = -5189738655874585053L;
@SuppressWarnings("unchecked")
public T clone() throws CloneNotSupportedException {
return (T)super.clone();
}
@SuppressWarnings("unchecked")
public T deepClone() throws IOException, ClassNotFoundException {
ByteArrayOutputStream bao = new ByteArrayOutputStream();
ObjectOutputStream obs = new ObjectOutputStream(bao);
obs.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (T)ois.readObject();
}
}
测试代码:
package basic;
import java.io.IOException;
public class Father extends PrototypeBasic<Father> {
/**
*
*/
private static final long serialVersionUID = 860498590845379201L;
private int fatherValue;
private String desc;
private Son son;
public Son getSon() {
return son;
}
public void setSon(Son son) {
this.son = son;
}
public int getFatherValue() {
return fatherValue;
}
public void setFatherValue(int fatherValue) {
this.fatherValue = fatherValue;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
Father f = new Father();
f.setFatherValue(4);
f.setDesc("desc");
Son son = new Son();
son.setStr("son prototype");
System.out.println("son's hashcode:" + son.hashCode());
f.setSon(son);
Father clone = f.clone();
Father deepClone = f.deepClone();
clone.setDesc("desc===clone");
System.out.println(f.getFatherValue() + " " + f.getDesc() + " " + f.getSon());
System.out.println(clone.getFatherValue() + " " + clone.getDesc() + " " + clone.getSon());
System.out.println(deepClone.getFatherValue() + " " + deepClone.getDesc() + " " + deepClone.getSon());
}
}
几点说明:
(一) 优点: 如果某个类想实现深浅复制功能,只需要和例子当中的Father类一样,继承抽象类PrototypeBasic,浅复制调用clone()方法,深复制调用deepClone()方法
(二) 缺点: 需要实现复制的类继承PrototypeBasic就不能继承其他类了,以后扩展会受到影响;需要复制类的属性如果有其他类的引用,那么该引用需要实现Cloneable, Serializable接口
代码只是即兴而写,只做了简单的深浅复制测试,不保证其他情况下不出现bug