java中cloneable的使用

什么是java中的浅克隆和深克隆?

• 浅克隆:克隆对象中的变量与之前对象的值相同,并且对象中的引用类型变量仍然指向原来对象引用类型变量的地址.
• 深克隆:克隆对象中的变量与之前对象的值相同，并且对象中的引用类型变量指向了新的对象的引用变量的地址.
• 要想实现克隆，只需定义的类声明下cloneable这个标记性接口,并且衍生重写Object类中就有的clone()方法即可.

为什么类要首先声明cloneable标记接口，然后重写clone()方法？因为不声明cloneable调用clone()方法会抛出CloneNotSupportedException异常,源码如下:

protected Object clone() throws CloneNotSupportedException {        if (!(this instanceof Cloneable)) {            throw new CloneNotSupportedException("Class " + getClass().getName() +                                                 " doesn't implement Cloneable");        }        return internalClone();    }    /*     * Native helper method for cloning.     */    private native Object internalClone();

---

在上一节中讲了java中Serializable与Parcelable的使用序列化与反序列化的问题。事实上利用对象输出流对对象进行序列化,利用对象的输入流对对象进行反序列化也可以实现克隆,如果对象中依赖的其他对象的引用也实现了序列化(即引用类实现了serializable标记接口)就实现了深度克隆,否则实现了浅克隆.

实现了Serializable接口的Company

public class Company implements Serializable {//Serializable接口是空的,没有声明的方法及常量    private static final long serialVersionUID = 1L; //序列化标识    private String name;    private String address;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getAddress() {        return address;    }    public void setAddress(String address) {        this.address = address;    }    public Company(String name, String address) {        this.name = name;        this.address = address;    }    @Override    public String toString() {        return "company name is:"+name+",address is:"+address;    }}

获得实现了Serializable接口的克隆实例调用方法。

private <T> T getCopyObj(T t) {        ByteArrayOutputStream byteArrayOutputStream = null;        ObjectOutputStream objectOutputStream = null;        ByteArrayInputStream byteArrayInputStream = null;        ObjectInputStream objectInputStream = null;        try {            byteArrayOutputStream = new ByteArrayOutputStream();            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);            objectOutputStream.writeObject(t);//序列化对象            objectOutputStream.flush();            byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());            objectInputStream = new ObjectInputStream(byteArrayInputStream);            T t1 = (T) objectInputStream.readObject();            return t1;        } catch (Exception e) {            e.printStackTrace();        } finally {            if (byteArrayOutputStream != null) {                try {                    byteArrayOutputStream.close();                    byteArrayOutputStream = null;                } catch (IOException e) {                    e.printStackTrace();                }            }            if (objectOutputStream != null) {                try {                    objectOutputStream.close();                    objectOutputStream = null;                } catch (IOException e) {                    e.printStackTrace();                }            }            if (byteArrayInputStream != null) {                try {                    byteArrayInputStream.close();                    byteArrayInputStream = null;                } catch (IOException e) {                    e.printStackTrace();                }            }            if (objectInputStream != null) {                try {                    objectInputStream.close();                    objectInputStream = null;                } catch (IOException e) {                    e.printStackTrace();                }            }        }        return null;    }}

测试通过的testCase，说明通过Serializable的反序列化创建的是一个新的对象,不再是之前的对象了。

    @Test    public void test() throws CloneNotSupportedException {        Company company=new Company("百度","上地十街");        Company copyCompany=getCopyObj(company);        copyCompany.setName("腾讯");        Assert.assertEquals(false,company==copyCompany);        Assert.assertEquals(true,company.getName().equals("百度"));        Assert.assertEquals(true,copyCompany.getName().equals("腾讯"));    }

---

实现了Clonable克隆的例子

public class People implements Cloneable {    private String name;    private int age;    public People(String name, int age) {        this.name = name;        this.age = age;    }    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone();    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

验证通过的case,表明了克隆出来的对象与原来的对象地址不一样,是一个新的对象,所以克隆对象中的name和age是新的.

    @Test    public void test() throws CloneNotSupportedException {        People people = new People("storm", 30);        People clonePeople = (People) people.clone();        clonePeople.setName("stormClone");        clonePeople.setAge(29);        Assert.assertFalse(people == clonePeople);        System.out.println("people name=" + people.getName());//people name=storm        System.out.println("people age=" + people.getAge());//people age=30        System.out.println("clonePeople name=" + clonePeople.getName());//clonePeople name=stormClone        System.out.println("clonePeople age=" + clonePeople.getAge());//clonePeople age=29    }

---

使用cloneable实现浅克隆

public class Animal {    private String animalName;    public Animal(String animalName) {        this.animalName = animalName;    }    public String getAnimalName() {        return animalName;    }    public void setAnimalName(String animalName) {        this.animalName = animalName;    }}

public class People implements Cloneable {    private String name;    private int age;    private Animal animal;//克隆对象中的引用型变量    public People(String name, int age,Animal animal) {        this.name = name;        this.age = age;        this.animal=animal;    }    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone();    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public Animal getAnimal() {        return animal;    }    public void setAnimal(Animal animal) {        this.animal = animal;    }}

验证通过的case，表明了克隆对象的引用型变量animal并未发生改变,也即使内存中的地址并未发生改变,所以对其name的更改会影响原对象与克隆对象的值.

    @Test    public void test() throws CloneNotSupportedException {        Animal animal=new Animal("cat");        People people = new People("storm", 30,animal);        People clonePeople = (People) people.clone();        animal.setAnimalName("dog");        Assert.assertFalse(people == clonePeople);        Assert.assertTrue(people.getAnimal()==clonePeople.getAnimal());        Assert.assertTrue(people.getAnimal().getAnimalName().equals("dog"));        Assert.assertTrue(clonePeople.getAnimal().getAnimalName().equals("dog")); }

---

使用cloneable实现深克隆(实现很简单只需要引用类型变量实现cloneable接口即可)，相比浅克隆,只需做如下修改.

public class Animal implements Cloneable{    private String animalName;    public Animal(String animalName) {        this.animalName = animalName;    }    public String getAnimalName() {        return animalName;    }    public void setAnimalName(String animalName) {        this.animalName = animalName;    }    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone();    }}

验证通过的case，表明了克隆对象的引用型变量animal发生改变,也即内存中的地址发生改变,所以对其name的更改不会影响克隆对象的值.同时说明了进行深克隆会把所有的引用类型都实现cloneable接口,如果克隆对象中的引用类型变量比较多的话,这牵涉的工作量就会比较大了,这时我们考虑使用上面实现Serializable实现克隆的方式,缺点是反复进行IO操作，内存开销大.

@Test    public void test() throws CloneNotSupportedException {        Animal animal=new Animal("cat");        People people = new People("storm", 30,animal);        People clonePeople = (People) people.clone();        Animal cloneAnimal=(Animal) animal.clone();        clonePeople.setAnimal(cloneAnimal);        animal.setAnimalName("dog");        Assert.assertFalse(people == clonePeople);        Assert.assertFalse(people.getAnimal()==clonePeople.getAnimal());        Assert.assertTrue(people.getAnimal().getAnimalName().equals("dog"));        Assert.assertTrue(clonePeople.getAnimal().getAnimalName().equals("cat"));    }