浅谈对java深拷贝与浅拷贝的理解

java中什么是浅拷贝？什么是深拷贝？

1.拷贝:实现对象复制的方式。
2.浅拷贝：被复制的对象的所有变量都含有原来对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之， 浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。
3.深拷贝：被复制对象的所有变量都含有与原来对象相同的值，而那些引用对象的变量将指向被复制过的新对象，而不再是原有 的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

直接上代码

1.简单的引用赋值

/**
 * 定义一个U类，同时实现Cloneable接口，重新clone方法
 * U类只包含一个域 address
 */
@AllArgsConstructor
@Data
class U implements Cloneable{
    private String address;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

/**
 * 定义一个User类，也实现Cloneable接口，同时重新clone方法
 * User类包含两个基本类型域，和一个引用类型域 u
 */
@Data
@AllArgsConstructor
class User implements Cloneable {
    private String name;
    private Integer age;
    private U u;
    @Override
    public User clone() throws CloneNotSupportedException {
        return (User)super.clone();
    }
}

  /**
     * 简单引用赋值
     * 效果：
     * 
     *通过user引用对User对象做的操作也会影响到user1引用所指向的对象，
     * 因为user与user1两个引用指向同一个User对像
     */
    @Test
    public void t1() {
        User user = new User("user", 30,new U("成都"));
        User user1 = user;
        //两个引用操作的都是同一个对象
        user.setAge(18);
        System.out.println(user);//User(name=wsm, age=18, u=U(address=成都))
        System.out.println(user1);//User(name=wsm, age=18, u=U(address=成都))
    }

2.克隆—浅拷贝

 /**
     * 克隆---浅拷贝
     * 效果：user与user1指向两个User对象,但是两对象中的u引用指向同一个U对象
     * 基本数据类型可以分离，但是引用类型还是指向同一个对象
     *
     * 注意：返回值中u的address域都是返回的“成都”
     *
     */
    @Test
    public void t2() throws CloneNotSupportedException {
        User user = new User("user", 30,new U("北京"));
        User user1 = user.clone();
        //改变基本数据类型
        user1.setAge(20);
        //改变引用类型 虽然修改的user1 但是user也改变了
        user1.getU().setAddress("成都");
        System.out.println("user="+user);//user=User(name=user, age=30, u=U(address=成都))
        System.out.println("user1="+user1);//user1=User(name=user, age=20, u=U(address=成都))
    }

3.克隆—深拷贝

@Data
@AllArgsConstructor
class Person implements Cloneable {
    private String name;
    private Integer age;
    private U u;
    /**
     * 如果U对象中又存在引用对象k，则K类也需要做深度拷贝
     * 所以问题就是深度拷贝很繁重，后期可以通过序列化来优化
     *
     * 注意：Object.clone方法是protected的，而且返回值是Object
     * 我们在重写clone方法时，将其改为public，同时返回我们需要的类型Person
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    public Person clone() throws CloneNotSupportedException {
        //拷贝 基本类型
        Person person=(Person)super.clone();
        //深度拷贝U对象
        person.u=(U)u.clone();
        return person;
    }
}

 /**
     * 克隆---深拷贝  效果： user和user1指向两个User对象，同时两对象中的u引用也指向两U对象
     * 实现原理查看Person.clone()
     *
     * @throws CloneNotSupportedException
     */
    @Test
    public void t3() throws CloneNotSupportedException {
        Person person = new Person("www", 20, new U("南京"));
        Person person1 = person.clone();
        person1.setAge(60);
        person.getU().setAddress("成都");
        System.out.println(person);//Person(name=www, age=20, u=U(address=成都))
        System.out.println(person1);//Person(name=www, age=60, u=U(address=南京))
    }

以上就是对java对象拷贝的简单认识，如有不足之处，欢迎大家指点。
以上代码将提交到码云地址
搬砖老王.