Dois-je déclarer/Initialiser ArrayLists que des Listes, des ArrayLists, ou ArrayLists de <Cat>

Quelle est la différence dans la déclaration d'une collection en tant que telle

public class CatHerder{
    private List cats;
    public CatHerder(){
        this.cats = new ArrayList<Cat>();
    }
}
//or
public class CatHerder{
    private ArrayList cats;
    public CatHerder(){
        this.cats = new ArrayList();
    }
}
//or
public class CatHerder{
    private ArrayList<Cat> cats;
    public CatHerder(){
        this.cats = new ArrayList<Cat>();
    }
}

OriginalL'auteur davidahines | 2011-03-30

22

Vous devez le déclarer comme une List<Cat>, et l'initialiser comme un ArrayList<Cat>.

List est une interface, et ArrayList est une application de classe. Il est presque toujours préférable de code par rapport à l'interface et non pas la mise en œuvre. De cette façon, si vous avez besoin de changer la mise en œuvre plus tard, il ne cassera pas les consommateurs qui code par rapport à l'interface.

Selon la façon dont vous l'utiliser effectivement la liste, vous pourriez même être en mesure d'utiliser le moins spécifique java.util.Collection (une interface qui List s'étend).

Comme pour List<Cat> (vous pouvez y lire que "la liste de chat") vs List: c'est de Java les génériques, qui assurent le type de compilation en toute sécurité. En bref, il permet au compilateur assurez-vous que le List ne contient Cat objets.
```
public class CatHerder{
    private final List<Cat> cats;
    public CatHerder(){
        this.cats = new ArrayList<Cat>();
    }
}
```
et le marquer comme final, si vous le réglez uniquement dans le constructeur.
bon point.
J'ai vu cet argument utilisé de nombreuses fois avant. Mais dans ce cas, il vous en fait voir qu'il est nécessaire de déclarer le type d'interface? Est-il un cas d'utilisation où l'on aurait initialiser un type de collection spécifique, ajouter des données à elle et puis un peu plus tard changé d'avis sur le type de collection?
href="http://programmers.stackexchange.com/q/225674/1845">programmers.stackexchange.com/q/225674/1845 et stackoverflow.com/a/505148/139010

OriginalL'auteur Matt Ball
4

Je ferais la suite.
```
public class CatHerder{
    private final List<Cat> cats = new ArrayList<Cat>();
}
```
6 ans plus tard, en supposant que java 7+ je préfère pour initialiser avec une Liste<Cat> les chats = new ArrayList<>();. J'ai pris cette place de l'eclipse plugin sonar. Citant Sonar id de règle 2293, "Java 7 a introduit le diamant (opérateur<>) pour réduire le niveau de verbosité des génériques de code. Par exemple, au lieu d'avoir à déclarer une Liste du type dans sa déclaration et de son constructeur, vous pouvez maintenant simplifier le constructeur déclaration avec <>, et le compilateur déduit le type."

OriginalL'auteur Peter Lawrey
1

Afin d'assurer la sécurité de type, et parce que les compilateurs Java va se plaindre si un type générique n'a pas de type d'argument, vous devez toujours spécifier un type de manière explicite ou <?> si vous n'avez vraiment pas de soins.

Cela dit, sauf si vous utilisez quelque chose de spécifique à la ArrayList classe, vous devez utiliser List<Cat> pour éviter d'encombrer votre code à un particulier List mise en œuvre.

OriginalL'auteur thkala
1

Comme Matt déjà déclaré, à l'aide de l'Interface la plus répandue/super-classe est la meilleure façon de le faire ici.
Assurez-vous de toujours déclarer le Type qui apparaît dans votre Liste, de sorte d'en faire un List<Cat> ou même List<? extends Cat>

Si, à un moment plus tard, vous voulez remplacer le ArrayList avec, disons, une LinkedList, vous n'aurez pas à modifier la déclaration, mais seulement l'instanciation.

OriginalL'auteur f1sh
1

List est plus flexible que ArrayList, List<Cat> est plus sûr que List. donc List<Cat> est un bon choix.

OriginalL'auteur 卢声远 Shengyuan Lu
1

Tout d'abord, List est une interface et ArrayList est une mise en œuvre de la List interface (en fait, il sous-classes AbstractList et implements List). Donc List cats = new ArrayList() est valable que depuis ArrayList est - List.

Pour cela:
```
private List cats;
```
cats devient une crue de type (il n'y a pas de référence pour le Type Générique pour List), il n'a pas été paramétré.

Votre 3ème solution est correcte (il permet de résoudre votre problème pour l'option 1),
```
private ArrayList<Cat> cats;
```
vous avez limité à un Type Générique E pour List<E> à un type Cat. Par conséquent, votre instanciation de cats est valable que pour le générique de cadre est le même.

Votre 2ème solution qui permet seulement ArrayList de cats peut être instancié. Les 2 autres options vous permet d'instancier un objet qui est - List, par exemple LinkedList.

OriginalL'auteur Buhake Sindi

Vous devez vous connecter pour publier un commentaire.