How to use Java deep copy, shallow copy and Cloneable interface

1. Introduction to Cloneable interface

Cloneable is a tagged interface (empty interface). They have no internal methods and properties. Implement Cloneable to indicate that the object can be cloned, The Object.clone() method can be used. If a class object that does not implement Cloneable calls clone(), a CloneNotSupportedException will be thrown.

It can be understood that the Cloneable interface plays a marking function. Custom types require users to mark which classes can be cloned. This mark is to implement the Cloneable interface and implement After adding the Cloneable interface, it indicates that the objects created by this class can be cloned.

If you want a class to have the function of copying instances, in addition to implementing the Cloneable interface, you must also override the clone() method of the Object class.

You can see that the clone() method of the Object class is modified by protected, so you need to call the Object class through the super keyword in the overridden clone() method. The clone() method in

2. Introduction and examples of shallow copy

When copying an object, the member variables of the object’s basic data type are Copying is performed, but only the reference is passed to the member variables of the reference type, and a new object is not created. When the content of the reference type is modified, it will affect the copied object. In short: Shallow copy only copies the object being copied, not the object it refers to.

Observe the following code, use the instance of the Money class as a field of the Person class, create a new object of the Person class, person1, and copy the person1 object to person2. The copy here is a shallow copy. , just copy the money reference of the person1 object to person2, and the momey in person1 and person2 point to the same object.

class Money {
    public double m = 666;
}
class Person implements Cloneable{
    int id;
    public Money money = new Money();

    public Person(int id) {
        this.id = id;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", money=" + money.m +
                '}';
    }
}
public class TestDemo3 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person(1);
        Person person2 = (Person) person1.clone();

        System.out.println("通过person2修改前的结果");
        System.out.println(person1);
        System.out.println(person2);

        person2.money.m = 888;
        person2.id = 2;
        System.out.println("通过person2修改后的结果");
        System.out.println(person1);
        System.out.println(person2);
    }
}

Execution results:

Shallow copy illustration:

3. Introduction to deep copy When copying an object, in addition to copying the member variables of the basic data type, when copying the member variables of the reference type, a new object is created to save the member variables of the reference type. In short:

Deep copy copies all the objects referenced by the object to be copied.

The following code implements deep copy; to implement deep copy of person1 object, first use Person tmp reference to save the result of shallow copy, find the money object through tmp reference, and then copy the money object , then assign it to money in tmp, and finally return tmp. In this way, the object referenced by money is also copied, realizing a deep copy. At this time, momey in person1 and person2 point to two different objects.

class Money implements Cloneable{
    public double m = 666;

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

}

class Person implements Cloneable{
    public int id;
    public Money money = new Money();

    public Person(int id) {
        this.id = id;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //return super.clone();
        Person tmp = (Person) super.clone();
        tmp.money = (Money) this.money.clone();
        return tmp;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", money=" + money.m +
                '}';
    }
}
public class Test2 {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person(1);
        Person person2 = (Person) person1.clone();

        System.out.println("通过person2修改前的结果");
        System.out.println(person1);
        System.out.println(person2);

        person2.money.m = 888;
        person2.id = 2;
        System.out.println("通过person2修改后的结果");
        System.out.println(person1);
        System.out.println(person2);
    }
}

Execution result:

Deep copy illustration:

4. Summary of clone method

The clone method in Java is a shallow copy, and the reference type is still passing the reference. We can implement deep copy by continuing to call the clone() method and implementing the clone() method again on the reference type variable of the object.

The above is the detailed content of How to use Java deep copy, shallow copy and Cloneable interface. For more information, please follow other related articles on the PHP Chinese website!