Discussion :

[lepak]

Hello!

Je bute sur un petit problème, j'ai ici une classe avec un type paramétré qui implémente la méthode clone()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public class MaClasse<T>
{
 
    private T param;
 
    public MaClasse(T param)
    {
        this.param = param;
    }
 
    public MaClasse(MaClasse uneAutreMaClasse)
    {
        this.param = (T) uneAutreMaClasse.param.clone();
    }
 
    @Override
    public MaClasse clone()
    {
        return new HpsToolPosition(this);
    }
}

Problème : clone() est une méthode protected, comme j'utilise un type paramétré, le package de T est donc java.lang, puisqu'il est considéré comme un Object.

Si je ne clone pas param, ça fonctionne, mais ça n'assure pas la copie profonde que l'on voudrait avec la méthode clone().

Est-ce qu'un de vous entreverrait une solution à ceci?

Merci d'avance!

[adiGuba]

Salut,


Quelques remarques :

• Le constructeur MaClasse(MaClasse) devrait utiliser un type paramétré lui aussi, soit : MaClasse(MaClasse<T>).
  A noter toutefois qu'en Java il est plutôt inhabituel d'utiliser un constructeur de copie comme ceci...
• Tu ne respectes pas les règles du cloneage en Java. Il ne faut pas créer un nouvel objet, mais implémenter l'interface Cloneable et retourner l'objet retourné par super.clone()
• Tu peux obliger le type T a être cloneable en le définissant comme ceci : <T extends Cloneable>.
  Malheureusement l'interface Cloneable ne définit pas de méthode clone(), donc tu dois passer par l'API de reflection pour l'appeler sur n'importe quel type implémentant Cloneable.

Bref cela donnerait quelque chose comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class MaClasse<T extends Cloneable> implements Cloneable {
 
    private T param;
 
    public MaClasse(T param) {
        this.param = param;
    }
 
    public MaClasse(MaClasse<T> uneAutreMaClasse) {
        this.param = uneAutreMaClasse.cloneParam();
    }
 
    /** Méthode interne qui permet de cloner le paramètre par reflection */
    private T cloneParam() {
        try {
            Method cloneMethod = Object.class.getMethod("clone");
            cloneMethod.setAccessible(true);
            @SuppressWarnings("unchecked")
            T clonedParam = (T) cloneMethod.invoke(this.param);
            return clonedParam;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
 
    @Override
    public MaClasse<T> clone() {
        try {
            @SuppressWarnings("unchecked")
            MaClasse<T> cloned = (MaClasse<T>) super.clone();
            cloned.param = cloned.cloneParam();
            return cloned;
        } catch (CloneNotSupportedException e) {
            // Ceci ne devrait jamais arriver tant qu'on implémente bien Cloneable
            throw new RuntimeException(e);
        }
    }
}

a++

[lepak]

Je crois que tu viens de révolutionner ma façon de voir Java
La réflexion, c'est une sorte d'introspection?

A noter toutefois qu'en Java il est plutôt inhabituel d'utiliser un constructeur de copie comme ceci...

C'est plus une habitude, c'est comme ça que mon prof de java m'avait montrer le clone, en utilisant un constructeur de copie, et ça m'est resté

Tu ne respectes pas les règles du cloneage en Java. Il ne faut pas créer un nouvel objet, mais implémenter l'interface Cloneable et retourner l'objet retourné par super.clone()

Par là, tu veux dire que pour faire bien, il faut laisser java cloner l'objet, et reprendre à la main ce qu'on a implémenté perso?


J'imagine que dans le clone(), lorsque tu as mis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cloned.param = cloned.cloneParam();

c'est plutôt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cloned.param = this.cloneParam();

?


En tout cas, grand merci, ça rox ton code!

[adiGuba]

La réflexion, c'est une sorte d'introspection?

Oui !

C'est plus une habitude, c'est comme ça que mon prof de java m'avait montrer le clone, en utilisant un constructeur de copie, et ça m'est resté

C'est très utilisé en C++ car c'est implicite lors d'une affectation/passage de paramètre, mais c'est assez rare en Java...

Par là, tu veux dire que pour faire bien, il faut laisser java cloner l'objet, et reprendre à la main ce qu'on a implémenté perso?

Oui par convention c'est ce qu'il faudrait faire (cf la javadoc de clone()).

Cela permet également d'être sûr que clone() renverra le bon type dans les éventuelles classes filles sans qu'on ait forcément besoin de redéfinir la méthode

J'imagine que dans le clone(), lorsque tu as mis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cloned.param = cloned.cloneParam();

c'est plutôt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cloned.param = this.cloneParam();

?

En fait c'est la même chose car à ce moment précis cloned.param et this.param référencent le même objet en mémoire


a++