这里我们就可以引入两个专业的术语：浅克隆（shallow clone）和深克隆（deep clone）。
所谓的浅克隆，顾名思义就是很表面的很表层的克隆，如果我们要克隆Administrator对象，只克隆他自身以及他包含的所有对象的引用地址。而深克隆，就是非浅克隆。克隆除自身以外所有的对象，包括自身所包含的所有对象实例。至于深克隆的层次，由具体的需求决定，也有“N层克隆”一说。但是，所有的基本（primitive）类型数据，无论是浅克隆还是深克隆，都会进行原值克隆。毕竟他们都不是对象，不是存储在堆中。（Java中所有的对象都是保存在堆中，而堆是供全局共享的。也就是说，如果同一个Java程序的不同方法，只要能拿到某个对象的引用，引用者就可以随意的修改对象的内部数据。）
要让一个对象进行克隆，其实就是两个步骤：1. 让该类实现java.lang.Cloneable接口；2. 重写（override）Object类的clone()方法。（并且在方法内部调用持有对象的clone()方法；如果有N多个持有的对象，那就要写N多的方法，突然改变了类的结构，还要重新修改clone()方法。）
public class CloneBean implements Serializable,Cloneable{private String st1 ;
private int i;
public String getSt1() {
return st1;
}
public void setSt1(String st1) {
this.st1 = st1;
}
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
//可以实现自身的 值克隆 ，如果在父类的克隆的时候， 显示的调用自身的克隆，并复制给
@Override
public Object clone() {
CloneBean cb = null;
try {
cb = (CloneBean) super.clone();//要调用 父类的 clone方法
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return cb;
}
}
public class ShallowClone implements Cloneable {
// 基本类型 每个对象一份
private int a;
private String b;
// 非基本类型 数组 对象， 复制的对象保持一个引用，相关的修改都会影响
private int[] c;
private CloneBean clonebean;
// 重写Object.clone()方法,并把protected改为public 《只是浅克隆， 如果要实现真正的深克隆，用到 序列化及反序列化》
@Override
public Object clone() {
ShallowClone sc = null;
try {
sc = (ShallowClone) super.clone();//要调用 父类的 clone方法
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
//sc.clonebean=(CloneBean)clonebean.clone(); 显示的调用 对象的克隆，也可以保持对象的新值，因为 本身对象又是一个新的对象
return sc;
}
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public String getB() {
return b;
}
public void setB(String b) {
this.b = b;
}
public int[] getC() {
return c;
}
public void setC(int[] c) {
this.c = c;
}
public CloneBean getClonebean() {
return clonebean;
}
public void setClonebean(CloneBean clonebean) {
this.clonebean = clonebean;
}
}
public class ShallowCloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
ShallowClone c1 = new ShallowClone();
// 对c1赋值
c1.setA(100);
c1.setB("clone1");
c1.setC(new int[] { 1000 });
CloneBean cb = new CloneBean();
cb.setI(10);
cb.setSt1("str1");
c1.setClonebean(cb);
System.out.println("克隆前: c1.a=" + c1.getA());
System.out.println("克隆前: c1.b=" + c1.getB());
System.out.println("克隆前: c1.c[0]=" + c1.getC()[0]);
System.out.println("克隆前: c1.cb.str1=" + c1.getClonebean().getSt1());
System.out.println("-----------");
// 克隆出对象c2,并对c2的属性A,B,C进行修改
ShallowClone c2 = (ShallowClone) c1.clone();
// 对c2进行修改
c2.setA(50);
c2.setB("clone2");
int[] a = c2.getC();
a[0] = 500;
c2.setC(a);
CloneBean cb1 = c2.getClonebean();
cb1.setSt1("tewtstewt");
c2.setClonebean(cb1);
System.out.println("克隆后: c1.a=" + c1.getA());
System.out.println("克隆后: c1.b=" + c1.getB());
System.out.println("克隆后: c1.c[0]=" + c1.getC()[0]);
System.out.println("克隆后: c1.cb.str1=" + c1.getClonebean().getSt1());
System.out.println("---------------");
System.out.println("克隆后: c2.a=" + c2.getA());
System.out.println("克隆后: c2.b=" + c2.getB());
System.out.println("克隆后: c2.c[0]=" + c2.getC()[0]);
System.out.println("克隆后: c2.cb.str1=" + c2.getClonebean().getSt1());
}
}
×××××××××××××××××××××用serializable来实现×××××××××××××××××××××××××××××××××××
//前提是对象以及对象内部 所有引用到的对象 都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。而类变量 是全局的，也不作序列化操作。
public class DeepClone implements Serializable
{
private static final long serialVersionUID = -4371342386287259388L;
private transient String transi;//修饰为不可瞬时的 不可序列化对象
public static int k;
private int a;
private String b;
private int[] c;
private CloneBean cb;//必须也是可串行化的
public int getA()
{
return a;
}
public void setA(int a)
{
this.a = a;
}
public String getB()
{
return b;
}
public void setB(String b)
{
this.b = b;
}
public int[] getC()
{
return c;
}
public void setC(int[] c)
{
this.c = c;
}
public CloneBean getCb() {
return cb;
}
public void setCb(CloneBean cb) {
this.cb = cb;
}
public String getTransi() {
return transi;
}
public void setTransi(String transi) {
this.transi = transi;
}
public static int getK() {
return k;
}
public static void setK(int k) {
DeepClone.k = k;
}
// 用序列化与反序列化实现深克隆
public Object deepClone() {
Object o = null;
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
oos.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos
.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
o = ois.readObject();
ois.close();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return o;
}
}
public class DeepCloneTest {
public static void main(String[] args) throws CloneNotSupportedException
{
DeepClone dc1 = new DeepClone();
// 对dc1赋值
dc1.setA(100);
dc1.setB("clone1");
dc1.setC(new int[] { 1000 });
CloneBean cb = new CloneBean();
cb.setSt1("deepClone...before...");
dc1.setCb(cb);
dc1.setTransi("transiant before");
DeepClone.k=100;
System.out.println("克隆前: dc1.a=" + dc1.getA());
System.out.println("克隆前: dc1.b=" + dc1.getB());
System.out.println("克隆前: dc1.c[0]=" + dc1.getC()[0]);
System.out.println("克隆前: dc1.cd.str1=" + dc1.getCb().getSt1());
System.out.println("克隆前: dc1.transiant=" + dc1.getTransi());
System.out.println("克隆前: dc1.k=" + DeepClone.k);
System.out.println("-----------");
//序列化的所有对象 都要 实现 序列化接口
DeepClone dc2 = (DeepClone)dc1.deepClone();
// 对c2进行修改
dc2.setA(50);
dc2.setB("clone2");
int[] a = dc2.getC();
a[0] = 500;
dc2.setC(a);
CloneBean cb2 = dc2.getCb();
cb2.setSt1("deepClone...after...");
dc2.setCb(cb2);
System.out.println(dc2.getTransi()); //null值 没有进行复用
System.out.println(DeepClone.k); //静态代码块 不用串行化，本身就是公用一块区域
dc2.setTransi("transiant after");
DeepClone.k=200;
System.out.println("克隆前: dc1.a=" + dc1.getA());
System.out.println("克隆前: dc1.b=" + dc1.getB());
System.out.println("克隆前: dc1.c[0]=" + dc1.getC()[0]);
System.out.println("克隆前: dc1.cd.str1=" + dc1.getCb().getSt1());
System.out.println("克隆前: dc1.transiant=" + dc1.getTransi());
System.out.println("克隆前: dc1.k=" + DeepClone.k);
System.out.println("-----------");
System.out.println("克隆后: dc2.a=" + dc2.getA());
System.out.println("克隆后: dc2.b=" + dc2.getB());
System.out.println("克隆后: dc2.c[0]=" + dc2.getC()[0]);
System.out.println("克隆后: dc1.cd.str1=" + dc2.getCb().getSt1());
System.out.println("克隆后: dc2.transiant=" + dc2.getTransi());
System.out.println("克隆后: dc2.k=" + DeepClone.k);
}
}
扫一扫
130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
