Discussion :

[hibou107]

Bonjour,
Normalement pour définir les types liste comme ArrayList:

Code :

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

private ArrayList<Phone> phones=new ArrayList <Phone>();

Pourquoi j'ai lu dans pas mal d'exemple de code dans les livres ou sur l'internet, la définition sous cette forme:

Code :

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

private Collection<Phone> phones=new ArrayList <Phone>();

C'est quoi la différence et l'intérêt?
Merci

[slim_java]

Salut,

une explication dans la FAQ

[hibou107]

Merci de ta réponse mais je ne comprends pas

Tout d'abord, afin de minimiser la quantité de code à modifier pour changer d'implémentation, il convient de toujours faire référence aux collections en utilisant les interfaces, seule l'étape de construction faisant référence à l'implémentation.

Donc pour la définition

Code :

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

List<Object> list = new ArrayList<Object>();

Peux tu m'expliquer l'avantage par rapport à

Code :

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

ArrayList<Object> list = new ArrayList<Object>();

Merci

[Nudger]

Bonsoir,

List<?> est une interface donc non instanciable.
ArrayList<?> est une implémentation de cette interface.

Il est possible dans du code de volontairement faire abstraction de l'implémentation pour manipuler un objet et de ne connaitre que son interface. Ca permet d'apporter plus de lisibilité au code.

S'il te prends l'envie de développer ta propre implémentation de List<?> (car tu estime que ArrayList n'est pas assez performante par exemple), alors ça sera très pratique pour toi que l'ensemble ton application manipule des List<?> car tu n'auras pas grand chose à changer pour amener ton appli à utiliser ta propre implémentation de List<?>.

[hibou107]

Bonjour,
Merci bien, tout est clair maintenant, ça me fait du bien d'aller me coucher maintenant!

[Nudger]

Alors bonne nuit.
Et n'hésite pas à appuyer sur le bouton en bas de la discussion

[hibou107]

J'ai encore une question sur ce problème.
Si je défini un objet par une interface, j'ai seulement le droit d'utiliser les méthodes de l'interface et pas dans les classes d'implémentation?
Par exemple, dans mon exemple, s'il existe une méthode dans Arraylist et n'a pas été définie dans List, peux je l'utiliser?
Merci

[thelvin]

Si je défini un objet par une interface, j'ai seulement le droit d'utiliser les méthodes de l'interface et pas dans les classes d'implémentation?

Oui.

Par exemple, dans mon exemple, s'il existe une méthode dans Arraylist et n'a pas été définie dans List, peux je l'utiliser?

Non. Du coup, si tu as besoin de manipuler des ArrayList et pas des List, alors garde une ArrayList sous le coude.

Bien sûr, si tu sais que la List est forcément une ArrayList, tu peux toujours faire un cast de List vers ArrayList. Mais c'est idiot. Si tu en as besoin, autant garder la ArrayList dès le départ. Si tu n'en as pas besoin, pourquoi t'imposer une ArrayList alors que n'importe quelle List ferait l'affaire ?

[adiGuba]

Salut,

Si je défini un objet par une interface, j'ai seulement le droit d'utiliser les méthodes de l'interface et pas dans les classes d'implémentation?

Tout à fait !

Par exemple, dans mon exemple, s'il existe une méthode dans Arraylist et n'a pas été définie dans List, peux je l'utiliser?

Il te faudra alors recaster en ArrayList... mais en règle général avec les collections tu n'en auras pas vraiment besoin dans la plupart des cas.
Si tu as réellement besoin d'utiliser une méthode spécifique, cela signifie que tu as fait trop d'abstraction de l'implémentation !!!


Après cela dépend du choix de l'interface que tu vas utiliser.
Plus tu restes proche de l'implémentation et plus tu auras des possibilités (avec List tu as accès à la quasi-totalité des méthode d'ArrayList, sauf trimToSize() si je ne me trompe pas).
Plus tu t'en éloignes et moins tu auras de possibilités, mais ton code sera encore plus générique.


Par exemple avec cette méthode qui se contente d'afficher tous les éléments d'une ArrayList :

Code :

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

1
2
3
4
5
    public void printAll(ArrayList<Object> list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }

La méthode est artificiellement limitée aux ArrayList<Object>, alors qu'on pourrait utiliser l'interface List :

Code :

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

1
2
3
4
5
    public void printAll(List<Object> list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }

On n'a fait que charger le type déclaré du paramètre, mais notre méthode est désormais un peu plus générique puisqu'elle peut être utilisée avec n'importe quelle liste (ArrayList, LinkedList, Vector, ...)

Code :

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

1
2
3
4
5
    public void printAll(Collection<Object> coll) {
        for (Object o : coll) {
            System.out.println(o);
        }
    }

Mieux : on n'a pas forcément besoin de la notion de liste ici. La notion de collection pourrait être amplement suffisante. Notre méthode acceptent désormais un plus grand nombre de type, comme les Set ou les Queue... le tout sans changer son code !

Code :

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

1
2
3
4
5
    public void printAll(Iterable<Object> elements) {
        for (Object o : elements) {
            System.out.println(o);
        }
    }

On peut même se contenter de l'interface Iterable, qui indique seulement que l'on peut parcourir un ensemble d'élément. Désormais on peut l'utiliser avec encore plus de type, qui ne sont pas forcément des Collections...

En changeant uniquement le type déclaré du paramètre, on a modifié notre méthode original qui n'acceptait que très peu de type (ArrayList<Object> ou classe fille), à une méthode acceptant un très grand nombre de type différent (tout ceux qui implémentent Iterable<Object>), le tout sans changer une ligne de code.

Ceci permet une plus grande souplesse. Dans ce cas précis on se contrefiche de savoir qu'on manipule une ArrayList, un HashSet, une Queue ou n'importe quelles autres implémentations. On a uniquement besoin de parcourir les éléments contenus.

Cela permet aux utilisateurs de ta méthode de l'utiliser quelque soit l'implémentation exact qu'ils utilisent...


a++

PS : C'est un peu hors-sujet, mais pour les mêmes raisons on pourrait aller encore plus loin avec les Generics et les wildcards, car l'abstraction y est différente :

Code :

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

1
2
3
4
5
    public void printAll(Iterable<? extends Object> elements) {
        for (Object o : elements) {
            System.out.println(o);
        }
    }

Désormais on n'est plus limité aux Iterable<Object> mais à n'importe quels Iterable<>

[hibou107]

Avec ta réponse elle dépasse le cadre de la question et m'a beaucoup aidé dans la compréhension générale,
merci!