How to use java shallow copy

1. Concept

Shallow copy will create a new object. The new object has no relationship with the original object itself. The new object is not equal to the original object, but the new object The properties are the same as those of the old object. Specifically, you can see the following differences:

(1) If the attribute is of a basic type (int, double, long, boolean, etc.), the value of the basic type is copied;

(2) If the attribute It is a reference type, and what is copied is the memory address (that is, the reference is copied but not the referenced object), so if one of the objects changes the address, it will affect the other object.

2. Principle

If the member variable of the prototype object is a value type, a copy will be copied to the cloned object, which means it will have an independent space in the heap; If the member variables of the prototype object are reference types, the address of the reference object is copied to the clone object, which means that the member variables of the prototype object and the clone object point to the same memory address. In other words, in shallow cloning, when an object is copied, only itself and the member variables of the value type it contains are copied, while the member objects of the reference type are not copied.

3. Use the instance

Implement the Cloneable interface on the class that needs to be copied and override its clone()method

class Father{
    String name;
    public Father(String name) {
        this.name=name;
    }
    @Override
    public String toString() {
        return "Father{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Son implements Cloneable {
    int age;
    String name;
    Father father;
    public Son(String name,int age) {
        this.age=age;
        this.name = name;
    }
    public Son(String name,int age, Father father) {
        this.age=age;
        this.name = name;
        this.father = father;
    }
    @Override
    public String toString() {
        return "Son{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", father=" + father +
                '}';
    }
    @Override
    protected Son clone() throws CloneNotSupportedException {
        return (Son) super.clone();
    }
}
public class test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Father f=new Father("bigFather");
        Son s1 = new Son("son1",13);
        s1.father=f;
        Son s2 = s1.clone();
        
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("s1==s2:"+(s1 == s2));//不相等
        System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//相等
        System.out.println();
 
        //但是他们的Father father 和String name的引用一样
        s1.age=12;
        s1.father.name="smallFather";//s1.father引用未变
        s1.name="son222";//类似 s1.name=new String("son222") 引用发生变化
        System.out.println("s1.Father==s2.Father:"+(s1.father == s2.father));//相等
        System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//不相等
        System.out.println(s1);
        System.out.println(s2);
    }
}

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