浅拷贝 深拷贝

浅拷贝

浅拷贝复制对象的时候，对于基本类型和String类型，是对字段值进行复制并重新分配内存空间，原对象和拷贝的新对象这些属性互不干扰；对于引用类型，只是重新分配引用变量的内存空间，指向的实际对象是同一个对象

public class Person implements Cloneable{
    public String pname;
    public int page;
    public Address address;
    public Person() {}

    public Person(String pname,int page){
        this.pname = pname;
        this.page = page;
        this.address = new Address();
    }


    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public void setAddress(String provices,String city ){
        address.setAddress(provices, city);
    }

    public void setAddressObj(Address obj) {
        this.address = obj;
    }
    public void display(String name){
        System.out.println(name+":"+"pname=" + pname + ", page=" + page +","+ address);
    }

    public String getPname() {
        return pname;
    }
    public void setPname(String pname) {
        this.pname = pname;
    }
    public int getPage() {
        return page;
    }
    public void setPage(int page) {
        this.page = page;
    }
}

public class Address {
    private String provices;
    private String city;

    public void setAddress(String provices,String city){
        this.provices = provices;
        this.city = city;
    }
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person("张三",21);
        p1.setAddress("陕西", "西安");
        Person p2 = (Person) p1.clone();
        System.out.println("p1:"+p1);

        System.out.println("p2:"+p2);

        p1.display("p1");
        p2.display("p2");

        p2.setAddress("山西", "太原");
        p2.setPname("李四");
        p2.setPage(20);
        System.out.println("==================");
        p1.display("p1");
        p2.display("p2");

        Person p3 = new Person("王素",45);
        p3.setAddress("北京", "朝阳");
        Person p4 = (Person)p3.clone();
        p3.display("p3");
        p4.display("p4");
        Address add = new Address();
        add.setAddress("湖北", "武汉");
        p3.setAddressObj(add);
        System.out.println("*******************");
        p3.display("p3");
        p4.display("p4");
    }
}

调用clone()方法，这个对象所属类必须实现Cloneable接口并重写clone()方法
clone()方法是Object提供的本地方法：@HotSpotIntrinsicCandidate protected native Object clone() throws CloneNotSupportedException;

从打印结果看出：

• 调用clone()的到的对象，和原对象不是同一个
• 对于基本类型和String类型的属性，会进行值的拷贝并且重新分配空间，所以修改两个对象的这类属性互补干扰。修改了p2中Stirng类型的属性pname，int类型的属性page，p1中的这两个属性并没有变化
• 对于引用类型，只是拷贝引用变量的值并分配空间，而不会拷贝引用所指向的对象，所以其中一个对象修改了引用对象，另一个对象中的引用对象也跟着修改了。address对象地址相同，修改p2中引用类型的属性时，p1的这个属性也跟着发生了变化；但是第p3的address属性重新赋值，并不会影响p4

深拷贝

深拷贝复制对象的时候，无论属性是基本类型还是引用类型，都会新赋值一份值重新分配空间，互不干扰

public class Address implements Cloneable{
    private String provices;
    private String city;

    public void setAddress(String provices,String city){
        this.provices = provices;
        this.city = city;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Person implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person p = (Person)super.clone();
        p.address = (Address)address.clone();
        return p;
    }
}