In fact, the key to the problem lies in the clone() method. We know that the clone() method uses the clone() method of the Object class, but this method has a defect. It does not copy all the attributes of the Object, but selectively. The basic rules are as follows:

       1. Basic type

         If the variable is a basic type, copy its value, such as int, float, etc.

       2. Object

         If the variable is an instance object, copy its address reference, that is, the new object and the original object share the instance variable.

       3. String string

         If the variable is a String, copy its address reference. However, when modifying, it will regenerate a new String from the String pool, and the original purple capital object will remain unchanged.

      Based on the above rules, we can easily find the problem. They share an object. If Zhang San modifies the content of the email, Li Si and Wang Wu will also modify it, so the above situation will occur. We can solve this problem. We just need to create an object in the clone() method, and then Zhang San references the object:

rotected Person clone() {
        Person person = null;
        try {
            person = (Person) super.clone();
            person.setEmail(new Email(person.getEmail().getObject(),person.getEmail().getContent()));
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        
        return person;
    }

Therefore: shallow copy is only a simple copy mechanism provided by Java, which is not convenient for direct use.

      There is still a problem with the above solution. If a large number of objects in our system are generated by copying, if we write a clone() method for each class, we will also need to make a deep copy and create a large number of objects. This project is very large. Here we can use serialization to copy objects.

How to use serialization to copy objects? It is easy to copy byte stream in memory. Write the parent object into a byte stream and read it from the byte stream. In this way, a new object can be created, and there is no reference sharing problem between the new object and the parent object, so as to truly realize the deep copy of the object.

public class CloneUtils {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T clone(T obj){
        T cloneObj = null;
        try {
            //Write byte stream
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ObjectOutputStream obs = new ObjectOutputStream(out);
            obs.writeObject(obj);
            obs.close();
            
            //Allocate memory, write the original object, and generate a new object
            ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(ios);
            //Returns the generated new object
            cloneObj = (T) ois.readObject();
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cloneObj;
    }
}

Objects using this tool class must implement the Serializable interface, otherwise there is no way to clone.

public class Person implements Serializable{
    private static final long serialVersionUID = 2631590509760908280L;

    ..................
    //Remove clone() method

}

public class Email implements Serializable{
    private static final long serialVersionUID = 1267293988171991494L;
    
    ....................
}

Therefore, objects using this tool class can clone objects as long as they implement the Serializable interface, and there is no need to inherit the clonable interface to implement the clone() method.

public class Client {
    public static void main(String[] args) {
        //Write an email
        Email email = new Email("Please attend the meeting","Please contact today 12:30 Attend the meeting in conference room 2...");
        
        Person person1 =  new Person("Zhang San",email);
        
        Person person2 =  CloneUtils.clone(person1);
        person2.setName("Li Si");
        Person person3 =  CloneUtils.clone(person1);
        person3.setName("Wang Wu");
        person1.getEmail().setContent("Please contact today 12:00 Attend the meeting in conference room 2...");
        
        System.out.println(person1.getName() + "The content of your email is:" + person1.getEmail().getContent());
        System.out.println(person2.getName() + "The content of your email is:" + person2.getEmail().getContent());
        System.out.println(person3.getName() + "The content of your email is:" + person3.getEmail().getContent());
    }
}
-------------------
Output:
The content of Zhang San's email is: please contact today 12:00 Attend the meeting in conference room 2...
The content of Li Si's email is: please contact today 12:30 Attend the meeting in conference room 2...
The content of Wang Wu's email is: please contact today 12:30 Attend the meeting in conference room 2...