對象的克隆

對象的克隆

1、克隆即復制的意思，對象的克隆，意味著生成一個對象，這個對象和某個對象的屬性和行為是一致的，但是這個對象和源對象是兩個不同的對象。實現對象的克隆，方法是實現Cloneable接口，否則會報異常CloneNotSupportedException

public class Demo implements Cloneable{
    private int number;
    private String name;
    
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


    public static void main(String[] args) {
        Demo demo = new Demo();
        Demo demo2 = null;
        try {
            demo2 = (Demo) demo.clone();
            System.out.println(demo==demo2);
            
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

輸出：

false

從結果我們可以知道，兩個引用指向的對象是兩個不同的Demo對象.

2、淺克隆

淺克隆是指在克隆對象的時候，對于對象中的屬性的值進行復制，那么這里引出一個問題，如對象的成員變量不論是基本類型還是引用類型，克隆對象的成員變量的值與源對象一致，這里引出一個問題，當成員變量是引用類型的時候，克隆對象和源對象的引用成員類型變量指向的是同一個對象，那么當這個對象本身的內容發生改動的時候，勢必影響到克隆對象和源對象，這樣在實際的生產過程可能帶來巨大問題。因此對象的克隆只在特定的場景下使用。

淺克隆的例子：

public class Demo implements Cloneable{
    private int number;
    private Person person;
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    public Person getPerson() {
        return person;
    }
    public void setPerson(Person person) {
        this.person = person;
    }
    
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.setNumber(10);
        Person person = new Person();
        person.setName("test");
        demo.setPerson(person);
        Demo demo2 = null;
        try {
            demo2 = (Demo) demo.clone();
            //很明顯，源對象和克隆對象的引用類型變量指向同一個Person對象
            System.out.println(demo.getPerson()==demo2.getPerson());
            System.out.println(demo.getPerson().getName()+":"+demo2.getPerson().getName());
            //person對象發生變動
            person.setName("demo");
            System.out.println(demo.getPerson().getName()+":"+demo2.getPerson().getName());
            
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

class Person{
    private String name;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

輸出結果：

true
test:test
demo:demo

3、深克隆

在克隆時引用類型的變量在源對象和克隆對象中指向同一個對象。那么能否做到克隆出來的對象的引用屬性指向的對象與源對象是兩個不同的對象呢？答案是可以的，這種克隆被稱為深克隆。與淺克隆區別在于，復制對象的時候，是否對源對象中的引用變量指向的對象進行拷貝。進行深克隆的常用的手段是通過流和序列化/反序列化來實現。

public class Demo implements Serializable{
    private int number;
    private Person person;
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    public Person getPerson() {
        return person;
    }
    public void setPerson(Person person) {
        this.person = person;
    }
    
    public static void main(String[] args){
        Demo demo = new Demo();
        demo.setNumber(10);
        Person person = new Person();
        person.setName("test");
        demo.setPerson(person);
        Demo demo2 = ObjectUtil.clone(demo);
        System.out.println(demo.getPerson()==demo2.getPerson());
        System.out.println(demo.getPerson().getName()+":"+demo2.getPerson().getName());
        //person對象發生變動
        person.setName("demo");
        System.out.println(demo.getPerson().getName()+":"+demo2.getPerson().getName());
    }
}

class Person implements Serializable{
    private String name;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

工具類：

public class ObjectUtil {
    @SuppressWarnings("unchecked")
    public static <T>T clone(T obj){
        T clonedObj = null;
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            //將對象寫進字節流中
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(obj);
            //從字節流中讀出對象
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            clonedObj = (T)ois.readObject();
        }catch (IOException e) {
            e.printStackTrace();
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return clonedObj;
    }
}

?