Discussion :

[AsmCode]

Salut

Dans ma classe je dois implémenter compareTo, mais je ne vois pas l'utilité d'écrire implements Comparable, car ça fonctionne si je me contente d'écrire ma méthode:

Code :

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

1
2
3
4
5
6
7
8
9
public int compareTo(Object o) {
 
        int result = -1;
        Location x = (Location)o;
 
        if (o instanceof Location) result = CodeInventaire.compareTo(x.obtCodeInventaire());
 
        return result;
    }

C'est pour gérer les exception, car je pourrais lui passer un objet null .. Mais je lis souvent qu'il faut implémenter l'interface comparable, mais je ne vois pas pourquoi, si quelqu'un pourrait me l'expliquer svp

[Pill_S]

Dans ma classe je dois implémenter compareTo, mais je ne vois pas l'utilité d'écrire implements Comparable, car ça fonctionne si je me contente d'écrire ma méthode...

Euh... le problème me semble plus général non ? Ce n'est pas uniquement avec Comparable que tu ne comprend pas, mais c'est l'utilisation des interfaces en général non ?

[AsmCode]

Ben non je sais ce que c'est qu'une interface j'en implémente une pour faire une liste chainée, c'est juste que je ne vois pas la différence entre redéfinir la méthode de cette interface et redéfinir celle de Object

[Gfx]

Object n'a pas de methode compareTo(). Implementer l'interface Comparable permet d'utiliser ta classe avec des methodes qui attendent des Comparable justement. Par exemple pour trier une liste tu peux utiliser Collections.sort() si ta List contient des objets qui sont du type Comparable. Si tu n'implementes pas cette interface, la bibliotheque n'aura aucun moyen d'etre sure que tu implementes bien compareTo().

[AsmCode]

Ok Mais je l'ai déclaré avec implements Comparable mais dans ma liste chainée il me dit que il trouve pas la méthode compareTo pour le type T

j'ai essayé T extends Comparable dans ma classe et il me renvoie un warning de la mort comme quoi c'est unsafe

[Gfx]

On peut voir ton code ? Il semblerait que tu as mal utilise les generics.

[AsmCode]

Voici ma classe chainée:

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
public class ListeChainee<T extends Comparable> implements ADTListe<T> {
 
    private Noeud<T> tete;
    private Noeud<T> fin;
    private int nbElements;
 
    ListeChainee() {
 
        tete = new Noeud<T>();
 
    }
 
    ListeChainee(T element) {
 
        this();
        fin = new Noeud<T>(element);
        fin.majSuivant(tete);
        tete = fin;
        nbElements = 1;
 
    }
 
    /**
     * Verification si la liste contient ou non des élements
     * @return true si la liste est vide, sinon false
     */
    public boolean estVide () {
 
        return (nbElements == 0);
 
    }
 
    /**
     * Retirer tous les élements de la liste. La liste sera vide
     * 
     */
    public void viderListe () {
 
        tete = fin;
        nbElements = 0;
 
    }
 
    /**
     * Retourne le nombre d'éléments de la liste
     * @return Nombre d'élements (int)
     */
    public int nbElements () {
 
        return nbElements;
 
    }
 
    /**
     * Ajoute l'élément au début de la liste
     * @return la référence de l'objet inséré ou null s'il y a eu un probleme
     */
    public T ajouterDebut (T element) {
 
        Noeud<T> nouveau;
        nouveau = new Noeud<T>(element);
 
        nouveau.majSuivant(tete);
        tete = nouveau;
 
        nbElements++;
 
        return tete.obtenirElement();
 
    }
 
    /**
     * Ajoute l'élément à la fin de la liste
     * @return la référence de l'objet inséré ou null s'il y a eu un probleme
     */
    public T ajouterFin (T element) {
 
        Noeud<T> nouveau;
        nouveau = new Noeud<T>(element);
 
        nouveau.majSuivant(fin.obtenirSuivant());
        fin.majSuivant(nouveau);
        fin = nouveau;
 
        nbElements++;    
 
        return fin.obtenirElement();
 
    }
 
    /**
     * Ajoute l'élément en ordre croissant (avec compareTo)
     * @return la référence de l'objet inséré ou null s'il y a eu un probleme
     **/
    public T ajouterOrdonne (T element) {
 
        Noeud<T> tmp = tete;
        Noeud<T> precedent = null;
        Noeud<T> nouveau;
 
        while (tmp.obtenirSuivant() != null && element.compareTo(tmp.obtenirElement()) > 0) {
 
            precedent = tmp;
            tmp = tmp.obtenirSuivant();
 
        }
 
            if (precedent == null) {
 
                ajouterDebut(element);
                tmp = tete;
 
            } else {
 
                nouveau = new Noeud<T>(element);            
                nouveau.majSuivant(tmp);
                precedent.majSuivant(nouveau);
                tmp = nouveau;
 
                nbElements++;   
            }
 
        return tmp.obtenirElement();
 
    }
 
}

Il me sort un warning comme quoi c'est unsafe. Mais ça compile.

Et voici ma classe Location c'est l'objet que je vais mettre dans ma liste chainee

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public class Location implements Comparable<Location> {
 
    // Statique, car c'est la même chose pour toute les instances de Location.
    private static SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.yyyy");
 
    private String CodeInventaire;
    private String Emprunteur;
    private Date DateLocation;
 
    public Location(String CodeInventaire, String Emprunteur) {
 
        this.CodeInventaire = CodeInventaire;
        this.Emprunteur = Emprunteur;
        this.DateLocation = new Date();
 
    }
 
    public String obtCodeInventaire() {
 
        return CodeInventaire;
 
    }
 
    public String obtEmprunteur() {
 
        return Emprunteur;
 
    }
 
    public String obtDateLocation() {
 
        return formatter.format(DateLocation);
 
    }
 
    public boolean equals(Object obj) {
 
        return CodeInventaire.equals(((Location)obj).obtCodeInventaire());
 
    }
 
    public int compareTo(Location unOutil) {
 
        return CodeInventaire.compareTo(unOutil.obtCodeInventaire());
 
    }
 
 
    public String toString() {
 
        return obtCodeInventaire() + "\n" + obtEmprunteur() + "\n" + obtDateLocation();
 
    }
 
} // Location

[Gfx]

Un warning unsafe signifie juste que quand tu utilises des generics certaines operations ne peuvent pas etre garanties type-safe. Ce n'est pas forcement une erreur de programmation. A quelle ligne as-tu ce warning exactement ? (Au fait, Java propose deja une liste chainee - a moins que ce ne soit un exercice