深拷贝和浅拷贝

深拷贝和浅拷贝

浅拷贝：只是增加一个指针指向已存在的内存地址

深拷贝：增加了一个指针并且申请了一个新的内存，使这个指针指向这个新的内存

在深拷贝的情况下，释放资源不会因为出现浅拷贝释放同时一个 内存的错误

Clone-对象克隆-进行深浅拷贝

clone 就是复制 ， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。

这和new 也是大同小异的：

new与clone创建对象的区别

new操作符的本意是分配内存。程序执行到new操作符时， 首先去看new操作符后面的类型，根据类型分配内存，再调用构造函数，填充对象的各个域，这一步就叫对象的初始化。初始化完毕后，可以把他的引用（地址）发布到外部，在外部就可以通过引用操纵这个对象。
clone在第一步是和new相似的，都是分配内存，调用clone方法时，分配的内存和源对象一样，然后再使用源对象中对应的各个域，填充新对象的域。同样可以可以把这个新对象的引用发布到外部 。

基本使用

本次就用users这个类来做实验

当然要注意的是在使用clone的时候，需要对象重写clone方法，对象才可以使用，并且要实现Cloneable这个接口

public class Users implements Cloneable {
    private String name;
    private String address;
    private int age;
    private char sex;
    private String[] obj;

    public Users() {
    }

    public Users(String name, String address, int age, char sex, String[] obj) {
        this.name = name;
        this.address = address;
        this.age = age;
        this.sex = sex;
        this.obj = obj;
    }

    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String[] getObj() {
        return obj;
    }

    public void setObj(String[] obj) {
        this.obj = obj;
    }

  // 重写clone方法
   @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

然后就可以进行简单的克隆了

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);
        Users clone = (Users) users.clone();
        System.out.println(clone);
        // 如果相等说明是同一个对象，就是浅拷贝
       System.out.println(clone);//Users{name='张三', address='重庆市', age=19, sex=男, obj=[hh, feig]}
  

    }
}

浅拷贝和深拷贝

上面age是基本数据类型， 对它的拷贝直接将一个4字节的整数值拷贝过来就行。但name是String类型的， 只是一个引用， 指向一个真正的String对象，对它的拷贝有两种：

• **浅拷贝:**直接将源对象中的name的引用值拷贝给新对象的name字段；
• **深拷贝：**根据User源对象中的name指向的字符串对象创建一个新的相同的字符串对象，将这个新字符串对象的引用赋给新拷贝的User对象的name字段。

Java中的clone方法是浅拷贝。

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);
        Users clone = (Users) users.clone();
        System.out.println(clone);
        // 如果相等说明是同一个对象，就是浅拷贝
        System.out.println(clone.getObj() == users.getObj());// true 
  

    }
}

== 如果两方是对象，那么比较的就是地址，所有上面克隆的对象和源对象的数组是指向的同一个地址，所以是浅拷贝

如果想要实现**深拷贝，**可以通过覆盖重写Object中的clone方法的方式。
要在clone对象时进行深拷贝，就要implements Clonable接口，覆盖并实现clone方法，除了调用父类中的clone方法得到新的对象， 还要将该类中的引用变量也clone出来。如果只是用Object中默认的clone方法，是浅拷贝的。

@Override
protected Object clone() throws CloneNotSupportedException {
    Users clone = (Users) super.clone(); //基本的数据类型可以直接拷贝
    //引用类型的数据就需要重新再复制一次，就可以实现深拷贝
    clone.obj= clone.obj.clone();
    return clone;
}

public class ObjectDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        String[] s1={"hh","feig"};
        String[] s2={"hh","feiwg"};
        Users users=new Users("张三","重庆市",19,'男',s1);
        Users users1=new Users("张三","重庆市",19,'男',s2);
        Users clone = (Users) users.clone();
        System.out.println(clone);
        // 如果相等说明是同一个对象，就是浅拷贝
        System.out.println(clone.getObj() == users.getObj());// false
  

    }
}