JAVA( Clonage : copies d’objets) : Exercice corrigé

• Énoncé : Vous devez créer une classe Personne qui contient les attributs suivants : nom, prénom, âge et adresse. La classe doit implémenter l’interface Cloneable et avoir une méthode clone() qui renvoie une copie de l’objet courant. Cette méthode doit utiliser super.clone() pour cloner l’objet et ensuite copier manuellement tous les attributs de la classe.
• Consignes :

1. Définissez la classe Personne avec les attributs et les méthodes demandés.
2. Implémentez l’interface Cloneable dans la classe Personne.
3. Créez une méthode clone() dans la classe Personne qui renvoie une copie de l’objet courant.
4. Utilisez super.clone() pour cloner l’objet et copiez ensuite manuellement tous les attributs de la classe.
5. Testez votre implémentation en créant une instance de la classe Personne, en la clonant et en comparant les deux objets.

• Exemple de solution :

public class Personne implements Cloneable {
    private String nom;
    private String prenom;
    private int age;
    private String adresse;

    public Personne(String nom, String prenom, int age, String adresse) {
        this.nom = nom;
        this.prenom = prenom;
        this.age = age;
        this.adresse = adresse;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getPrenom() {
        return prenom;
    }

    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAdresse() {
        return adresse;
    }

    public void setAdresse(String adresse) {
        this.adresse = adresse;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        Personne clone = (Personne) super.clone();
        clone.setNom(this.nom);
        clone.setPrenom(this.prenom);
        clone.setAge(this.age);
        clone.setAdresse(this.adresse);
        return clone;
    }

    @Override
    public String toString() {
        return "Personne [nom=" + nom + ", prenom=" + prenom + ", age=" + age + ", adresse=" + adresse + "]";
    }
}

Dans cet exemple, la classe Personne implémente l’interface Cloneable, ce qui signifie que nous pouvons utiliser la méthode clone() pour créer une copie de l’objet courant. Nous utilisons super.clone() pour cloner l’objet, puis nous copions manuellement tous les attributs de la classe. Enfin, nous retournons une copie de l’objet cloné.

Pour tester notre implémentation, nous pouvons créer une instance de la classe Personne, la cloner, puis comparer les deux objets pour voir s’ils sont égaux :

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Personne p1 = new Personne("FADI", "ABDO", 31, "237 Saada 1 - El jadaida");
        Personne p2 = (Personne) p1.clone();
  }
}

La méthode clone() de l’exemple que j’ai fourni effectue une copie profonde de l’objet Personne. Cela signifie que tous les attributs de l’objet sont clonés, y compris les objets référencés. Si la méthode clone() se contentait de retourner (Personne) super.clone();, cela produirait une copie superficielle de l’objet, où les objets référencés ne seraient pas clonés.

En effet, lorsqu’on utilise super.clone(), la méthode de la classe parente est appelée, qui effectue une copie superficielle de l’objet. Ensuite, dans la méthode clone() de la classe Personne, on effectue une copie profonde en clonant les objets référencés par les attributs de la classe. Cela permet de garantir que les objets référencés par l’objet original et l’objet cloné sont indépendants les uns des autres.

Par conséquent, pour assurer une copie profonde de l’objet Personne, il est nécessaire de redéfinir la méthode clone() et de cloner tous les objets référencés dans l’objet original.

Voici une implémentation de la méthode clone() pour la classe Personne qui effectue une copie superficielle de l’objet :

public Object clone() throws CloneNotSupportedException {
    return super.clone();
}