Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Construtor de cópia, cópia superficial e cópia profunda

Um construtor de cópia cria uma instância a partir de outra. Uma cópia superficial continua a partilhar objetos aninhados; uma cópia profunda separa o estado mutável abrangido pelo contrato de cópia.

Versão: Java SE 21

Sintaxe

T(T source) { /* initialize the new instance from source */ }
T copy = new T(source);

Um construtor de cópia é um construtor normal que recebe uma instância da mesma classe, como T(T source). O Java SE 21 não o gera automaticamente. Em new T(source), a sobrecarga é selecionada em tempo de compilação, e a implementação decide o que copiar ou partilhar. Pelo contrário, T alias = source só copia a referência e não cria um objeto.

Uma cópia superficial cria um novo objeto exterior, mas copia os valores dos campos tal como estão, sejam valores primitivos ou referências. Uma alteração num objeto mutável partilhado é visível através de ambas as instâncias. Um campo de referência final impede a reatribuição, não a alteração do objeto referenciado. A implementação base de Object.clone() faz uma cópia superficial e lança CloneNotSupportedException se o objeto não implementar Cloneable. Um construtor de cópia não exige esta interface.

Uma cópia profunda recria também os objetos mutáveis aninhados abrangidos pelo contrato de cópia. As alterações a esse estado não se propagam entre o original e a cópia. Os objetos imutáveis podem ser partilhados. Um novo contentor não basta se os seus elementos mutáveis continuarem a ser partilhados.

Para preservar os ciclos e os nós partilhados num grafo de objetos, regista cada par original–cópia por identidade, por exemplo num IdentityHashMap, antes de seguires as referências do nó. Várias referências ao mesmo nó conduzem à mesma cópia e os ciclos não provocam recursão infinita.

Exemplos

public class Main {
    static final class Box {
        private final int[] values;

        private Box(int[] values) {
            this.values = values;
        }

        Box(Box source) {
            this(source.values.clone());
        }

        static Box shallowCopyOf(Box source) {
            return new Box(source.values);
        }
    }

    public static void main(String[] args) {
        Box original = new Box(new int[] {1});
        Box shallow = Box.shallowCopyOf(original);
        Box deep = new Box(original);

        System.out.println("Distinct boxes: " + (original != shallow) + ", " + (original != deep));
        System.out.println("Shared arrays: " + (original.values == shallow.values)
                + ", " + (original.values == deep.values));

        shallow.values[0] = 7;
        deep.values[0] = 9;
        System.out.println("Values: original=" + original.values[0]
                + ", shallow=" + shallow.values[0] + ", deep=" + deep.values[0]);
    }
}

Resultado

Distinct boxes: true, true
Shared arrays: true, false
Values: original=7, shallow=7, deep=9

Ambas as cópias são novos objetos `Box`; só `shallow` partilha o seu array com `original`. Uma alteração através de `shallow` põe a `7` o valor visível em `original`, enquanto uma alteração através de `deep` põe apenas o seu próprio valor a `9`. Clonar um `int[]` basta porque os elementos são primitivos; clonar um array de referências não copia os objetos referenciados.

Lições relacionadas

  • Java · Lição 6 · Avançado · Versão: 2

Fontes