【Java深拷贝与浅拷贝 深克隆与浅克隆】

深拷贝与浅拷贝

浅拷贝

public class Address {
    private String city;
    public Address() {
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    public Address(String city) {
        this.city = city;
    }
}

public class Person implements Cloneable{
    private String nickname;
    private Address address;

    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public Person() {
    }
    public Person(String nickname, Address address) {
        this.nickname = nickname;
        this.address = address;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 默认浅拷贝
 		return super.clone();
    }
}

public class PersonTest {
    @Test
    public void test03()throws CloneNotSupportedException{
        Person person = new Person("张三",new Address("上海"));
        System.out.println(person.getAddress().getCity());
        // clone的返回值类型是Object类型 需要向下转型
        Person clone = (Person) person.clone();
        System.out.println(clone.getAddress().getCity());
        person.setNickname("李四");
        person.getAddress().setCity("北京");
        System.out.println(person.getNickname());
        System.out.println(person.getAddress().getCity());
        System.out.println(clone.getNickname());
        System.out.println(clone.getAddress().getCity());
    }
}

输出

上海
上海
李四
北京
张三
北京

深拷贝

方式一：

public class Address implements Cloneable{
    private String city;
    public Address() {
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    public Address(String city) {
        this.city = city;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Person implements Cloneable{
    private String nickname;
    private Address address;
    public Person(String nickname, String city) {
    }
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public Person() {
    }

    public Person(String nickname, Address address) {
        this.nickname = nickname;
        this.address = address;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 默认浅拷贝
        // return super.clone();
        // 深拷贝
        // 一种是在Address克隆一次 另一种如下：
        //return new Person(this.nickname,new Address(this.getAddress().getCity()));
        return new Person(this.nickname, (Address) this.getAddress().clone());
    }
}

public class PersonTest {
    @Test
    public void test03()throws CloneNotSupportedException{
        Person person = new Person("张三",new Address("上海"));
        System.out.println(person.getAddress().getCity());
        // clone的返回值类型是Object类型 需要向下转型
        Person clone = (Person) person.clone();
        System.out.println(clone.getAddress().getCity());
        person.setNickname("李四");
        person.getAddress().setCity("北京");
        System.out.println(person.getNickname());
        System.out.println(person.getAddress().getCity());
        System.out.println(clone.getNickname());
        System.out.println(clone.getAddress().getCity());
    }
}

输出

上海
上海
李四
北京
张三
上海

方式二：

public class Address{
    private String city;

    public Address() {
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    public Address(String city) {
        this.city = city;
    }
}

public class Person implements Cloneable{
    private String nickname;
    private Address address;
    public Person(String nickname, String city) {
    }
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public Person() {
    }
    public Person(String nickname, Address address) {
        this.nickname = nickname;
        this.address = address;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 默认浅拷贝
        // return super.clone();
        // 深拷贝
        // 一种是在Address克隆一次 另一种如下：
        return new Person(this.nickname,new Address(this.getAddress().getCity()));
        //return new Person(this.nickname, (Address) this.getAddress().clone());
    }
}

public class PersonTest {
    @Test
    public void test03()throws CloneNotSupportedException{
        Person person = new Person("张三",new Address("上海"));
        System.out.println(person.getAddress().getCity());
        // clone的返回值类型是Object类型 需要向下转型
        Person clone = (Person) person.clone();
        System.out.println(clone.getAddress().getCity());
        person.setNickname("李四");
        person.getAddress().setCity("北京");
        System.out.println(person.getNickname());
        System.out.println(person.getAddress().getCity());
        System.out.println(clone.getNickname());
        System.out.println(clone.getAddress().getCity());
    }
}

输出

上海
上海
李四
北京
张三
上海

深克隆与浅克隆

浅克隆（Shallow clone）

浅客隆是指拷贝对象时仅仅copy对象本身和对象中的基本变量，而不拷贝对象包含的引用指向的对象

public class Address implements Cloneable{
    private String city;
    public Address() {
    }
    public Address(String city) {
        this.city = city;
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class PersonShallow implements Cloneable{
    private String nickname;
    private Address address;
    public PersonShallow() {
    }
    public PersonShallow(String nickname, Address address) {
        this.nickname = nickname;
        this.address = address;
    }
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    public static void main(String[] args) {
        Address address = new Address("上海");
        PersonShallow person = new PersonShallow("张三",address);
        try{
            PersonShallow clone = (PersonShallow) person.clone();
            System.out.println(person==clone);
            System.out.println(person.getClass()==clone.getClass());
            System.out.println(person.getAddress()==clone.getAddress());
            System.out.println(person.getAddress().getClass()==clone.getAddress().getClass());
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
    }
}

输出

false
true
true
true

深克隆（deep clone）

不仅copy对象本身，而且copy对象包含的引用指向的所有对象

public class Address implements Cloneable{
    private String city;
    public Address() {
    }
    public Address(String city) {
        this.city = city;
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class PersonDeep implements Cloneable{
    private String nickname;
    private Address address;
    public PersonDeep() {
    }
    public PersonDeep(String nickname, Address address) {
        this.nickname = nickname;
        this.address = address;
    }
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        PersonDeep personDeep = (PersonDeep)super.clone();
        Address address = (Address)personDeep.getAddress().clone();
        personDeep.setAddress(address);
        return personDeep;
    }
    public static void main(String[] args) {
        Address address = new Address("上海");
        PersonDeep person = new PersonDeep("张三",address);
        try{
            PersonDeep clone = (PersonDeep) person.clone();
            System.out.println(person==clone);
            System.out.println(person.getClass()==clone.getClass());
            System.out.println(person.getAddress()==clone.getAddress());
            System.out.println(person.getAddress().getClass()==clone.getAddress().getClass());
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
    }
}

输出

false
true
false
true

---