Discussion :

[aliasjcdenton]

Bonjour,

Je ne comprends pas quelle est la différence entre :

Code :

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

ArrayList maListe = new ArrayList();

et

Code :

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

Collection maListe = new ArrayList();

Quels sont les avantages/désavantages de chaque méthode ?

Merci d'avance pour vos éclaircissements !

[thelvin]

Code :

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

ArrayList maListe = new ArrayList();

En faisant ainsi ta variable est de type ArrayList, et tu peux appeler les méthodes ArrayList dessus.
Mais tout le code qui se sert de cette variable, exige que cette variable soit un ArrayList et ne marchera pas, par exemple avec une LinkedList ou un HashSet.

Code :

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

Collection maListe = new ArrayList();

En faisant ainsi ta variable est de type Collection. Tu ne peux pas appeler la méthode trimToSize() dessus, parce que c'est une méthode fournie uniquement par ArrayList.
Par contre, le code qui se sert de ta variable, se fiche à partir de maintenant, que cet objet soit un ArrayList, un LinkedList, un HashSet ou n'importe quelle Collection. Il marche avec absolument toutes les Collection, sans rien changer.

Par ailleurs :

En réalité de nos jours il faut utiliser les génériques. Quelque chose comme :

Code :

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

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

ou

Code :

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

Collection<String> list = new ArrayList<String>();

[aliasjcdenton]

Désolé pour ma réponse tardive.

Mais je ne comprends pas pourquoi ne pas utiliser

Code :

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

Collection<String> list = new Collection<String>();

puisqu'en utilisant

Code :

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

Collection<String> list = new ArrayList<String>();

, on ne peut de toute façon pas utiliser les méthodes propres à ArrayList.

Quel intérêt ?

Merci d'avance pour la réponse !

[andry.aime]

Bonjour,

Tu ne peux pas parce que Collection est une interface et non pas une classe (On ne peut pas instancier aussi une classe abstraite) mais la classe instanciée doit obligatoirement implémenté l'interface. Pour l'intérêt, tu peux voir ici.

A+.

[kox2ee]

Bonjour,
l'intérêt est également de donner la possibilité de faire évoluer, sans nouvelle modification de code.

Si tu déclares une classe composée d'une Collection de la façon suivante :

Code :

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

1
2
3
4
5
6
7
8
 
public class MaClasse{
	private Collection<String> strings;
 
	public MaClasse(Collection<String> strings) {
		this.strings=strings;
	}
}

Tu as la possibilité, dans des programmes, d'utiliser MaClasse des façons suivantes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
//Instance avec des strings dans un tableau dynamique
MaClasse instance1=new MaClasse(new ArrayList<String>());
 
//Instance avec des strings dans une liste chaînée
MaClasse instance2=new MaClasse(new LinkedList<String>());
 
//Instance avec des strings uniques
MaClasse instance3=new MaClasse(new HashSet<String>());
 
//Instance avec des strings triés
MaClasse instance4=new MaClasse(new ArrayList<String>());

Tu auras donc la possibilité d'utiliser ta classe et d'en obtenir des comportements différents, sans modifier son code, ce qui permet la réutilisabilité.

Avec la déclaration :
ArrayList strings = new ArrayList();

pas possible !

[tchize_]

Pour faire les choses simplement.

Si ta variable est utilisée uniquement en interne, utilise le type explicite.

Par contre, si ta variable doit être exposée à d'autres classes, utilise les interfaces, ça permet de ne pas forcer l'appelant à utiliser un type déterminé alors qu'il voudrait en utiliser un autre.

[andry.aime]

Pour faire les choses simplement.

Si ta variable est utilisée uniquement en interne, utilise le type explicite.

Par contre, si ta variable doit être exposée à d'autres classes, utilise les interfaces, ça permet de ne pas forcer l'appelant à utiliser un type déterminé alors qu'il voudrait en utiliser un autre.

Je pense que tu voulais dire private local d'une méthode avec "en interne". Mais dans ce cas, c'est la même chose de déclarer une interface qui défini tous les besoins et de déclarer une classe.

A+.

[tchize_]

En ce qui me concerne, c'est juste une habitude ui me semble raisonnable.

Si j'ai besoin de faire ceci:

Code :

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

1
2
3
4
5
6
7
public void maMethode(){
  //...
  X x = ...
  x.add(...);
  x.add(...);
  //...
}

Je trouve inutile d'aller jouer avec deux types, je me contente de directement mettre ArrayList, ou LinkedList dans X. Le jour ou je change d'avis, ca n'influence rien, j'ai juste le type interne à la méthode à change.

Par contre si je fait ceci

Code :

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

1
2
3
public void maMethode(X x){
  //...
}

Alors X est une interface pour ne pas forcer un type du coté de l'appelant.
Après tout, pour revenir à la uestion initiale du pourquoi. Si je fais ceci:

Code :

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

public void maMethode(ArrayList<Integer> liste)

L'appelant, si il a une LinkedList<Integer>, ou une List<Integer> dont l'implémentation concretes est indéterminée, il sera obligé de faire ça

Code :

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

1
2
LinkedList<Integer> l = .....;
unTruc.maMethode(new ArrayList<Integer>(l));

ce qui est moche

Pareil si je m'en fou de l'ordre, je vais faire un

Code :

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

public void maMethode(Collection<Integer> liste)

Histoire de ne pas me retrouver à devoir faire un jour

Code :

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

1
2
Set<Integer> set = .....;
unTruc.maMethode(new ArrayList<Integer>(set));

[aliasjcdenton]

Merci à tous pour vos réponses ! J'ai bien compris maintenant.