clone的一知半解-Java

    Java中要实现clone必须实现Cloneable接口，并重写clone方法。但是惊奇的发现接口中居然空无一物，clone方法是在Object中就有定义的。

    像Cloneable这样的接口被称作标记接口，其意义是：以接口的形式标记对象是否拥有某种能力。这也是接口的一种作用，为某种规范而存在（个人理解，有看法可讨论）。关于标记相关，详见：http://www.cnblogs.com/xinhuaxuan/p/6349165.html

clone分 深clone和浅clone。

Java中Object实现的克隆为浅克隆，若对象A中有其他对象P，则若A 中的对象P发生改变时，其克隆对象A`中的P也会改变，因为其使用的引用指向同一个对象。

若想实现深克隆，需重写clone方法。可以采用序列化的方式，使用对象流实现。但被克隆对象需要实现Serializable接口

package lc.clone.deep;import java.io.Serializable;//要实现深克隆必须实现Serializable接口 public class DeepClone implements Serializable{    private int a;    private String b;    private int[] c;    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;    }}

测试类：

package lc.clone.deep;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;public class Test{    public static void main(String[] args) throws CloneNotSupportedException    {        Test t = new Test();        DeepClone dc1 = new DeepClone();        // 对dc1赋值         dc1.setA(100);        dc1.setB("clone1");        dc1.setC(new int[] { 1000 });        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("-----------");        DeepClone dc2 = (DeepClone) t.deepClone(dc1);        // 对c2进行修改         dc2.setA(50);        dc2.setB("clone2");        int[] a = dc2.getC();        a[0] = 500;        dc2.setC(a);        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("-----------");        System.out.println("克隆后: dc2.a=" + dc2.getA());        System.out.println("克隆后: dc2.b=" + dc2.getB());        System.out.println("克隆后: dc2.c[0]=" + dc2.getC()[0]);    }    // 用序列化与反序列化实现深克隆     public Object deepClone(Object src)    {        Object o = null;        try        {            if (src != null)            {                ByteArrayOutputStream baos = new ByteArrayOutputStream();                ObjectOutputStream oos = new ObjectOutputStream(baos);                oos.writeObject(src);                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;    }}

测试结果如下：

结果:
克隆前: dc1.a=100
克隆前: dc1.b=clone1
克隆前: dc1.c[0]=1000
-----------
克隆前: dc1.a=100
克隆前: dc1.b=clone1
克隆前: dc1.c[0]=1000
-----------
克隆后: dc2.a=50
克隆后: dc2.b=clone2
克隆后: dc2.c[0]=500

详见：http://blog.csdn.net/liuchao1211/article/details/3277955

关于可序列化内容，日后更新学习。