Java的深拷贝与浅拷贝

在学习C++时,老师说过值传递与引用传递。Java中只有值传递。今天我们就来讨论一下什么是浅拷贝与深拷贝。
先写一个例子给大家:
创建一个消费者类,其中包含属性,构造方法与get set方法.

public class Buyer {
    String name;
    int Level;
    char sex;
    double price;
    
    public Buyer(String name,int level, char sex, double price) {
        this.name = name;
        this.Level = level;
        this.sex = sex;
        this.price = price;
    }

对这个类进行创建工作:

public class BuyeTest {
    public static void main(String[] args) {
        Buyer buyter1 = new Buyer("小张",13,'男',100.3);
        Buyer buyter2 = buyter1;
        buyter1.setLevel(10);
                //打印两个对象
        System.out.println(buyter1);
        System.out.println(buyter2);
    }
}

image.png

结果在我们意料之内,只创建了一个对象,两个变量同时指向同一个地址,所以一改全改.
那有什么办法能够不创建对象,然而得到多个独立的对象呢?答案是有的,那就是拷贝.在实现拷贝之前要实现一个接口:

image.png

在object类中有clone()方法,我们只需要在子类中调用clone()方法即可,那么我们来试一试。

---

调用父类的clone方法

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

---

再次使用clone方法拷贝对象

public class BuyeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Buyer buyter1 = new Buyer("小张",13,'男',100.3);
        Buyer buyter2 = (Buyer) buyter1.clone();
        buyter1.setLevel(10);
        System.out.println(buyter1);
        System.out.println(buyter2);
    }
}

结果:

image.png

符合预期效果，浅拷贝完成，为什么说他是浅拷贝呢？已经是两个独立的对象了呀？其实并不是。

浅拷贝

• 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。
• 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
  举个例子：
  我们创建一个商品类,包含属性,构造方法与get set 方法

public class Product {
    String name;
    double proPrice;

    public Product(String name, double proPrice) {
        this.name = name;
        this.proPrice = proPrice;
    }
}

• 商品类与消费者类关联

public class Buyer implements Cloneable{
    String name;
    int Level;
    char sex;
    double price;
    Product product;
    
    public Buyer(String name,int level, char sex, double price,Product product) {
        this.name = name;
        this.Level = level;
        this.sex = sex;
        this.price = price;
        this.product = product;
    }
}
用同样方法进行复制对象:
public class BuyeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        // 创建Product类
        Product product = new Product("饼干", 15.3);
        Buyer buyter1 = new Buyer("小张", 13, '男', 100.3, product);
        Buyer buyter2 = (Buyer) buyter1.clone();
        buyter1.getProduct().setName("蛋糕");
        System.out.println(buyter1);
        System.out.println(buyter2);
    }
}

image.png

修改了其中一个对象的值,另一个也随之改变,并非完全独立.

---

使用深拷贝来解决这个问题:

• 方式1重写clone方法,对下一层对象进行clone
  Product类中实现父类的clone方法

@Override
    public String toString() {
        return "Product [name=" + name + ", proPrice=" + proPrice + "]";
    }

Buyer类中重写clone方法

@Override
    protected Object clone() throws CloneNotSupportedException {
        Buyer buyter = (Buyer)super.clone();
        Product product  = (Product)buyter.getProduct().clone();
        buyter.setProduct(product);
        return buyter;
    }

再次运行结果

image.png

方法1 能够解决问题,但是一旦遇到复杂的对象,递归遍历对象图就会消耗大量时间空间.

---

• 方法2:对象序列化,类都要实现Serializable接口,如果又不需要序列化的属性使用transient关键字

    //方法2
    protected Object deepClone() throws Exception {
//      将Buyer转换为字节流(序列化)
        ByteArrayOutputStream bos = new ByteArrayOutputStream(); // 字节数组输出流
        ObjectOutputStream oos = new ObjectOutputStream(bos); // 对象输出流(用于实现序列化)
        oos.writeObject(this);

        // 将字节流转换为新的Buyer(反序列化)
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); // 创建字节数组输入流，传入"序列化后的字节流"
        ObjectInputStream ois = new ObjectInputStream(bis); // 对象输入流(用于实现反序列化)
        Buyer buyer = (Buyer) ois.readObject();
        return buyer;

    }

测试

public static void main(String[] args) throws Exception {
        // 创建Product类
        Product product = new Product("饼干", 15.3);
        Buyer buyter1 = new Buyer("小张", 13, '男', 100.3, product);
//      Buyer buyter2 = (Buyer) buyter1.clone();
//      buyter1.getProduct().setName("蛋糕");
//      System.out.println(buyter1);
//      System.out.println(buyter2);
        Buyer buyter3 = (Buyer) buyter1.deepClone();
        buyter3.getProduct().setName("水果");
        System.out.println(buyter1);
        System.out.println(buyter3);

结果

image.png