Define Copy constructor in java.

In Java, a copy constructor can be defined to create a new object by copying the attributes of an existing object. Here’s a simple implementation:

class Person {
    String name;
    int age;

    // Copy constructor
    Person(Person p) {
        this.name = p.name;
        this.age = p.age;
    }
    
    // Method to display person details
    void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person original = new Person();
        original.name = "John";
        original.age = 30;

        // Create a copy using the copy constructor
        Person copy = new Person(original);
        
        // Display details
        original.display(); // Output: Name: John, Age: 30
        copy.display(); // Output: Name: John, Age: 30
    }
}

In this example, the Person class has a copy constructor that takes another Person object as a parameter. It copies the name and age fields, allowing you to create a new instance with the same values as the original.

When dealing with objects that contain references to other objects, it’s essential to understand the difference between a shallow copy and a deep copy. Here’s an example illustrating this:

class Address {
    String city;
    String state;

    Address(String city, String state) {
        this.city = city;
        this.state = state;
    }
}

class Person {
    String name;
    Address address;

    // Shallow copy constructor
    Person(Person p) {
        this.name = p.name;
        this.address = p.address; // Reference copied (shallow copy)
    }
    
    // Deep copy constructor
    Person(Person p, boolean deepCopy) {
        this.name = p.name;
        if (deepCopy) {
            this.address = new Address(p.address.city, p.address.state); // New object (deep copy)
        } else {
            this.address = p.address; // Reference copied (shallow copy)
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Address addr = new Address("New York", "NY");
        Person original = new Person();
        original.name = "John";
        original.address = addr;

        // Creating a shallow copy
        Person shallowCopy = new Person(original);
        // Creating a deep copy
        Person deepCopy = new Person(original, true);

        // Modifying original address
        original.address.city = "Los Angeles";

        // Displaying results
        System.out.println(shallowCopy.address.city); // Output: Los Angeles (shallow copy affected)
        System.out.println(deepCopy.address.city); // Output: New York (deep copy unaffected)
    }
}

In this example, the shallow copy shares the same reference to the Address object, while the deep copy creates a new Address instance, preventing unintended modifications.

When your class contains collections, implementing a copy constructor requires careful handling. Here’s an example using an ArrayList:

import java.util.ArrayList;

class Team {
    String name;
    ArrayList<String> members;

    // Copy constructor
    Team(Team t) {
        this.name = t.name;
        this.members = new ArrayList<>(t.members); // Deep copy of the list
    }
}

public class Main {
    public static void main(String[] args) {
        Team original = new Team();
        original.name = "Developers";
        original.members = new ArrayList<>();
        original.members.add("Alice");
        original.members.add("Bob");

        // Create a copy of the team
        Team copy = new Team(original);
        
        // Modifying original team
        original.members.add("Charlie");

        // Displaying results
        System.out.println(copy.members); // Output: [Alice, Bob] (copy unaffected)
        System.out.println(original.members); // Output: [Alice, Bob, Charlie]
    }
}

In this example, the Team class uses a copy constructor that creates a new ArrayList for the members field, ensuring that changes to the original team do not affect the copy.