Méthode clone()

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 43 sur 87.

La méthode clone() crée une copie d'un objet. Pour l'utiliser, votre classe doit implémenter l'interface Cloneable et surcharger la méthode clone() de la classe Object.

public class Person implements Cloneable {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public Person clone() {
        try {
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

Vous pouvez maintenant créer des copies indépendantes d'objets :

Person original = new Person("Alice", 25);
Person copy = original.clone();
// copy est un objet distinct avec les mêmes valeurs

Par défaut, clone() effectue une copie superficielle, ce qui signifie qu'elle copie les valeurs primitives et les références. Si votre objet contient d'autres objets en tant que champs, l'original et le clone référenceront tous deux les mêmes objets imbriqués. Pour obtenir des copies véritablement indépendantes avec des objets imbriqués, vous devez implémenter une copie profonde en clonant également ces objets imbriqués dans votre méthode clone().

Défi

Facile

Construisons un système de gestion de documents qui démontre le clonage d'objets. Vous allez créer une classe Document qui peut être clonée pour créer des copies indépendantes, permettant aux utilisateurs de dupliquer des documents tout en gardant l'original intact.

Vous organiserez votre code sur deux fichiers :

Document.java : Créez une classe représentant un document qui supporte le clonage. Un Document possède trois champs privés : title (String), author (String), et version (int). Incluez un constructeur pour initialiser tous les champs et des méthodes getter pour chacun. Ajoutez également une méthode setVersion(int version) pour mettre à jour le numéro de version.
Faites en sorte que votre classe Document implémente l'interface Cloneable et surchargez la méthode clone() pour renvoyer un Document. Gérez l'exception CloneNotSupportedException à l'intérieur de la méthode en l'enveloppant dans une RuntimeException.

Surchargez toString() pour renvoyer : Document[title=X, author=Y, version=Z] où X, Y et Z sont les valeurs réelles des champs.
Main.java : Donnez vie à votre classe Document en créant un document et en le clonant. Vous recevrez trois entrées : un titre (String), un auteur (String) et un numéro de version (int).
Créez un Document original avec ces valeurs, puis clonez-le pour créer une copie. Après le clonage, modifiez la version de la copie en l'incrémentant de 1 à l'aide de setVersion(). Cela démontre que le clone est véritablement indépendant de l'original.

Affichez trois lignes :
1. Original: suivi du toString() du document original
2. Clone: suivi du toString() du document cloné
3. Independent: suivi de true ou false indiquant si l'original et le clone sont des objets différents (utilisez la comparaison !=)

Vous recevrez trois entrées : le titre du document (String), le nom de l'auteur (String) et le numéro de version (int).

Remarquez comment, après avoir modifié la version du clone, le document original reste inchangé — cela prouve que clone() a créé une copie véritablement indépendante !

Aide-mémoire

La méthode clone() crée une copie d'un objet. Pour l'utiliser, votre classe doit implémenter l'interface Cloneable et redéfinir la méthode clone() de la classe Object :

public class Person implements Cloneable {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public Person clone() {
        try {
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

Création de copies indépendantes :

Person original = new Person("Alice", 25);
Person copy = original.clone();
// copy is a separate object with the same values

Par défaut, clone() effectue une copie superficielle (shallow copy), en copiant les valeurs primitives et les références. Si votre objet contient d'autres objets en tant que champs, l'original et le clone feront tous deux référence aux mêmes objets imbriqués. Pour obtenir des copies véritablement indépendantes avec des objets imbriqués, implémentez une copie profonde (deep copy) en clonant également ces objets imbriqués dans votre méthode clone().

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les entrées
        String title = scanner.nextLine();
        String author = scanner.nextLine();
        int version = scanner.nextInt();
        
        // TODO: Créer un Document original avec les valeurs d'entrée
        
        // TODO: Cloner le document original pour créer une copie
        
        // TODO: Modifier la version du clone en l'incrémentant de 1
        
        // TODO: Afficher "Original: " suivi du document original
        
        // TODO: Afficher "Clone: " suivi du document cloné
        
        // TODO: Afficher "Independent: " suivi de true/false (vérifier si original != clone)
        
    }
}