Why Does Copying One Object to Another in Java Yield Different Results?

What causes different results when copying one object to another in Java?

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getters and Setters
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 30);
        Person person2 = person1;  // Reference Copy

        person2.setName("Bob");  // Modifying person2 affects person1

        System.out.println(person1.getName()); // Outputs: Bob
    }
}

In Java, copying objects can lead to unexpected results due to Java's handling of object references and memory. When we copy an object, we must understand whether we're performing a shallow copy or a deep copy.

public class Person implements Cloneable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Override clone method for a deep copy
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

Causes

• Reference-type Copying: Assigning one object to another variable copies only the reference, not the object itself.
• Mutability: If an object contains mutable fields (like arrays or other objects), changes to one can affect the other if only a reference copy is made.
• Default Object Cloning: The default clone method of an object only performs a shallow copy.

Solutions

• Use copy constructors or factory methods to create new objects with the same values for a deep copy.
• Implement the Cloneable interface and override the clone() method to define custom deep copy behavior.
• Use serialization and deserialization for a more generic deep copying mechanism.

Mistake: Assuming a direct assignment copies the entire object.

Solution: Understand the distinction between reference copying and value copying.

Mistake: Not recognizing when objects have mutable fields, which can lead to side effects.

Solution: Consider using defensive copies for mutable objects.