Discussion :

[adiGuba]

Salut,



Attention gros pavé !!!!




Une dernière remarque : le fait d'utiliser des interfaces permet de donner une plus grande abstractions à notre code. Mis à part quelques cas particulier on devrait toujours utiliser les interfaces dans notre code.


Par exemple prenons cette méthode dont l'objectif est d'afficher une liste d'objet. Le code est tout bête :

Code :

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

1
2
3
4
5
6
7
public void print(ArrayList list) {
 
	for (int i=0; i<list.size(); i++) {
		System.out.println(list.get(i));
	}
 
}

Le premier défaut de cette méthode vient du fait qu'elle attend une ArrayList. Or le développeur qui va vouloir utiliser cette méthode pourrait avoir une autre type de List (pour quelque raison que ce soit), qu'il devra alors recopier dans une ArrayList avant de l'afficher

Et tout cela uniquement car on a déclaré utiliser une ArrayList. On dans le cas présent on se contrefout du type précis de la liste. En modifiant le type du paramètre ArrayList en List on obtient un code un peu plus générique :

Code :

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

1
2
3
4
5
6
7
public void print(List list) {
 
	for (int i=0; i<list.size(); i++) {
		System.out.println(list.get(i));
	}
 
}

On peut donc désormais utiliser notre méthode avec n'importe quel type de List, même des implémentations qui nous serait inconnu !

On rencontre alors le second problème : l'accès direct aux éléments via get() qui peut se révéler vraiment catastrophique selon l'implémentation (par exemple dans le cas d'une LinkedList). Lorsqu'on parcourt les éléments d'une List, il est fortement recommandé de passer par un Iterator :

Code :

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

1
2
3
4
5
6
7
8
public void print(List list) {
 
	Iterator i = list.iterator();
	while (i.hasNext()) {
		System.out.println(i.next());
	}
 
}

A partir de là, on peut encore élargir les possibilités d'utilisation : l'accès par index est inutile dans notre méthode, et on peut donc remplacé List par Collection, ce qui nous permettra de l'utiliser avec encore plus d'implémentations différentes (dont les Set), le tout via une modification mineure :

Code :

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

1
2
3
4
5
6
7
8
public void print(Collection col) {
 
	Iterator i = col.iterator();
	while (i.hasNext()) {
		System.out.println(i.next());
	}
 
}

Bref en modifiant légèrement le type du paramètre, et en parcourant correctement la liste, on passe d'une méthode limité aux ArrayList à une méthode bien plus générique pouvant accepter un très grand nombre d'implémentation.


Et Depuis Java 5.0 on peut faire encore mieux.

A commencer par les erreurs, puisque avec Java 5.0 les Collections sont Generics on serait tenter de faire ceci :

Code :

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

1
2
3
4
5
6
7
8
public void print(Collection<Object> col) {
 
	Iterator<Object> i = col.iterator();
	while (i.hasNext()) {
		System.out.println(i.next());
	}
 
}

Problème : Collection<Object> impose que la collection soit paramétré en <Object> précisément, ce qui limite une nouvelle fois notre méthode. Par exemple il est impossible dans l'état actuel de lui passer une Collection<String> ou une Collection<Date> car le typage des paramètres Generics est très fort...

Il faut utiliser le wildcard <? extends Object> qui indique qu'on accepte n'importe quelle liste paramétré avec un objet étendant de Object. Cela nous limitera toutefois l'accès à certaines méthodes permettant de modifier la collection (car on ne connait pas le paramétrage précis de la collection), mais cela nous est complètement inutile :

Code :

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

1
2
3
4
5
6
7
8
public void print(Collection<? extends Object> col) {
 
	Iterator<? extends Object> i = col.iterator();
	while (i.hasNext()) {
		System.out.println(i.next());
	}
 
}

A noter que dans le cas particulier de Object, <? extends Object> peut s'écrire <?> et que l'on peut également utiliser le for-étendu de Java 5.0 :

Code :

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

1
2
3
4
5
6
7
public void print(Collection<?> col) {
 
	for (Object obj : col) {
		System.out.println(obj);
	}
 
}

Enfin, Java 5.0 inclut également une interface Iterable utilisé par tous les éléments contenant un Iterator, ce qui semble parfaitement adapté à notre cas :

Code :

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

1
2
3
4
5
6
7
public void print(Iterable<?> elements) {
 
	for (Object obj : elements) {
		System.out.println(obj);
	}
 
}

Et nous voilà avec une méthode encore plus générique !




En fait il faudrait toujours essayer d'utiliser l'interface la plus basique selon nos besoins, afin de rester le plus générique possible.
Il n'y a que quelques cas où l'on a réellement besoin du type concret :

• Lors de l'instanciation de l'objet (le new XXX()).
• Lorsqu'on a besoin d'une méthode spécifique de cette objet (par exemple le trimToSize() d'ArrayList).
• Lorsque une certain implémentation est requise pour notre besoin (mais c'est rarement le cas).

a++

[wafiwafi]

Merci pour ces indications supplémentaires et surtout pertinentes.

[nicolofontana12]

Juste pour terminer, il faut aussi noter que Vector est deprecated. Il n'est present que pour assurer la compatibilité.. Donc fortement deconseillé à utiliser.

[tchize_]

heu non! Il est pas deprecated.

Par contre il ne respecte pas 100% les contraintes de l'interface List (notamment, il est synchronisé et final)

[adiGuba]

Par contre il ne respecte pas 100% les contraintes de l'interface List (notamment, il est synchronisé et final)

Heu... Non plus !

La classe Vector n'est pas deprecated mais elle respecte bien l'interface List. Le fait d'être synchronisé n'y change rien et la classe n'est pas du tout final (de toute manière je ne vois pas ce que cela changerait par rapport à l'implémentation de List).

a++

[tchize_]

arf, faut que le je mette à jour, c'était en jdk 1.0/1.1 qu'elle était final