What is the copy constructor pattern in Java, and how do you implement a correct one?

## What problem are we solving? Sometimes you have an existing object and want a brand-new, independent object that starts with the same data. For example, you have a `Point(x=3, y=4)` and want a second point with the same coordinates that you can move around without affecting the first. The mechanism Java offers for this is the **copy constructor**. ## What is a constructor? A **constructor** is a special method that runs when you create an object with the `new` keyword. It has the same name as the class and no return type. Its job is to initialize the new object's fields (its internal variables). ## What is a copy constructor? A **copy constructor** is simply a constructor whose single parameter is *another object of the same class*. Inside it, you copy each field from that other object into the object being created: ```java public class Point { private final int x; private final int y; public Point(int x, int y) { // normal constructor this.x = x; this.y = y; } public Point(Point other) { // copy constructor this.x = other.x; this.y = other.y; } } ``` Note: Java does **not** generate a copy constructor for you (this is different from C++). If you want one, you write it. ## Shallow vs deep copy — the key subtlety A field can hold either a *value* (like an `int`) or a *reference* (a pointer to another object, like a `List` or an array). When you copy a reference, you copy the arrow, not the thing it points to. - **Shallow copy:** copy the reference. The new object and the original now share the *same* underlying object. If that shared object is mutable, changing it through one affects the other. - **Deep copy:** create a fresh copy of the referenced object too, so the two are fully independent. ```java public class Team { private final String name; private final List<String> members; public Team(Team other) { this.name = other.name; // String is immutable: sharing is safe this.members = new ArrayList<>(other.members); // DEEP copy: independent list } } ``` If you had written `this.members = other.members;` (shallow), adding a member to the copy would also add it to the original — usually a bug. Immutable types (like `String`, `Integer`, `LocalDate`) are safe to share, so you don't need to deep-copy them. ## Why prefer copy constructors over clone()? Java has an older copying mechanism: implement `Cloneable` and override `Object.clone()`. It is widely considered broken: - `clone()` returns `Object`, so callers must cast. - `Cloneable` is a marker interface that doesn't actually declare `clone()`, so the contract is awkward. - `Object.clone()` bypasses constructors, which can leave invariants or `final` fields in odd states. A copy constructor avoids all of this: it is ordinary, type-safe code; it runs real constructor logic; it can assign `final` fields; and a copy *factory method* variant (`static Point copyOf(Point p)`) can even return a chosen subtype. Joshua Bloch's *Effective Java* explicitly recommends copy constructors/factories over `Cloneable`. ## A caveat with inheritance A copy constructor only knows about the exact type it is written for. If you call `new Animal(someDog)` where `someDog` is actually a `Dog`, you get a plain `Animal`, losing the dog-specific state (this is sometimes called *slicing*). A copy *factory* that delegates, or a polymorphic `copy()` method overridden per subclass, addresses this when needed.