java克隆之淺層克隆與深層克隆

一、淺層克隆

public class Shallow implements Cloneable
{
    int age = 0;
    // 存在類屬性
    Inner in = new Inner();

    public static void main(String[] args)
    {
        Shallow s = new Shallow();
        Shallow s2 = s.clone();
        s2.age = 1;
        s2.in.token = 1;
        System.out.println(s);// Shallow [age=0, in=Inner [token=1]]
        System.out.println(s2);// Shallow [age=1, in=Inner [token=1]]
        System.out.println(s.in.getWhichObject());// com.lv.test.abstractTest.Shallow$Inner@6fd46259
        System.out.println(s2.in.getWhichObject());// com.lv.test.abstractTest.Shallow$Inner@6fd46259
    }

    /**
     * 淺層複製
     * 
     * 對於類屬性，只會複製引用
     */
    @Override
    public Shallow clone()
    {
        try
        {
            return (Shallow) super.clone();
        } catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public String toString()
    {
        return "Shallow [age=" + age + ", in=" + in + "]";
    }

    class Inner
    {
        int token = 0;

        @Override
        public String toString()
        {
            return "Inner [token=" + token + "]";
        }

        public String getWhichObject()
        {
            return super.toString();
        }
    }
}

上邊代碼中的克隆方法調用的是基類Object的克隆方法。Object的克隆是淺層克隆。通過main方法的執行，可以發現，在淺層克隆中，克隆對象與原對象並不是完全獨立的，其基本屬性（int，String等）是獨立的，而起引用型屬性指向同一對象in。當克隆對象改變in的屬性時，原對象也會發生改變。

二、深度克隆

public class Deep implements Serializable
{
    private static final long serialVersionUID = 1L;

    int token = 0;
    // 引用型屬性
    Inner in = new Inner();

    public static void main(String[] args)
    {
        Deep s = new Deep();
        Deep s2 = s.clone();
        s2.token = 1;
        s2.in.token = 1;
        System.out.println(s);// Deep [token=0, in=Inner [token=0]]
        System.out.println(s2);// Deep [token=1, in=Inner [token=1]]
        System.out.println(s.in.getWhichObject());// com.lv.test.abstractTest.Deep$Inner@51d9d7ab
        System.out.println(s2.in.getWhichObject());// com.lv.test.abstractTest.Deep$Inner@248a4156
    }

    /**
     * 深度克隆
     */
    public Deep clone()
    {
        ByteArrayOutputStream baos = null;
        ObjectInputStream ois = null;
        try
        {
            new ObjectOutputStream(baos = new ByteArrayOutputStream()).writeObject(this);
            // 從流裏讀出來
            ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
            return (Deep) ois.readObject();
        } catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public String toString()
    {
        return "Deep [token=" + token + ", in=" + in + "]";
    }

    class Inner implements Serializable
    {
        private static final long serialVersionUID = 1L;

        int token = 0;

        @Override
        public String toString()
        {
            return "Inner [token=" + token + "]";
        }

        public String getWhichObject()
        {
            return super.toString();
        }
    }
}

通過流將對象完全複製一份。通過main方法可以看到前後兩個對象的in屬性的內存地址是不一樣的。