Copying objects safely without a broken clone

Understanding Copying objects safely without a broken clone

Object.clone() does not build an object the way new does. It allocates an instance of the same runtime class, skips every constructor, and copies each field's value straight across; for a reference field the value is the reference itself, so the original and the copy end up naming the same ArrayList or the same array. None of the validation or defensive copying your constructor performs is repeated, and a subclass cannot patch things up afterwards for a final field, because a final field can only be assigned during construction.

Cloneable does not rescue this, because it is a marker interface that declares no methods at all. It does not give your class a clone() method, Object.clone() is protected so thing.clone() from outside the class still does not compile, and typing a variable as Cloneable buys you nothing. The only thing the interface does is flip a runtime check: without it Object.clone() throws CloneNotSupportedException, a checked exception you are forced to catch even in a class where it can never be thrown.

The useful mental model is that copying is a constructor's job, and the only real question is which fields the new object must own rather than share. Immutable components such as String, int, LocalDate, or another value object are safe to share because nobody can change them behind your back; mutable ones such as collections, arrays, StringBuilder, or objects you created must be rebuilt, and if their elements are mutable too you have to decide how far down to go. A copy constructor or a static copyOf factory runs the real constructor, works with final fields, throws no checked exception, and can be documented; when callers hold a supertype reference and do not know the concrete class, add a copy() method to that supertype and let each subclass implement it.

import java.util.ArrayList;
import java.util.List;

class Basket implements Cloneable {
    String owner;
    List<String> items = new ArrayList<>();

    Basket(String owner) { this.owner = owner; }

    @Override
    public Basket clone() {                 // field-for-field, exactly one level deep
        try {
            return (Basket) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);    // cannot happen: we implement Cloneable
        }
    }
}

class Cart {
    private final String owner;
    private final List<String> items;

    Cart(String owner, List<String> items) {
        this.owner = owner;
        this.items = new ArrayList<>(items);   // own the list, do not adopt it
    }

    Cart(Cart other) {                         // copy constructor
        this(other.owner, other.items);        // reuse the real constructor
    }

    void add(String item) { items.add(item); }

    @Override
    public String toString() { return owner + " -> " + items; }
}

public class Main {
    public static void main(String[] args) {
        Basket b1 = new Basket("ana");
        b1.items.add("apple");
        Basket b2 = b1.clone();
        b2.items.add("pear");
        System.out.println("clone:  " + b1.items + " " + b2.items);
        System.out.println("shared: " + (b1.items == b2.items));

        Cart c1 = new Cart("ana", List.of("apple"));
        Cart c2 = new Cart(c1);
        c2.add("pear");
        System.out.println("copy:   " + c1 + " | " + c2);
    }
}

Worked examples

import java.util.ArrayList;
import java.util.List;

abstract class Node {
    final String id;
    Node(String id) { this.id = id; }
    abstract Node copy();
    @Override public String toString() { return getClass().getSimpleName() + "(" + id + ")"; }
}

class Leaf extends Node {
    Leaf(String id) { super(id); }
    @Override Leaf copy() { return new Leaf(id); }
}

class Group extends Node {
    final List<Node> children = new ArrayList<>();
    Group(String id) { super(id); }
    @Override Group copy() {
        Group g = new Group(id);
        for (Node child : children) g.children.add(child.copy());
        return g;
    }
}

public class Main {
    public static void main(String[] args) {
        Group root = new Group("root");
        root.children.add(new Leaf("a"));

        Group duplicate = root.copy();
        duplicate.children.add(new Leaf("b"));

        System.out.println(root.children);
        System.out.println(duplicate.children);
        System.out.println(root.children.get(0) == duplicate.children.get(0));
    }
}

import java.util.Arrays;

record Reading(String sensor, double[] samples) {
    Reading {                                   // compact canonical constructor
        samples = samples.clone();              // copy in
    }

    @Override public double[] samples() {
        return samples.clone();                 // copy out
    }
}

public class Main {
    public static void main(String[] args) {
        double[] raw = { 1.0, 2.0 };
        Reading r = new Reading("t1", raw);

        raw[0] = 99.0;                          // caller mutates its own array
        System.out.println(Arrays.toString(r.samples()));

        r.samples()[1] = 42.0;                  // mutates a throwaway array
        System.out.println(Arrays.toString(r.samples()));

        System.out.println(r.samples() == r.samples());
    }
}

Important notes

Common mistakes

Try it yourself