Java Générique List<List<? s'étend Nombre>>

Comment venir en java on ne peut pas faire:

List<List<? extends Number>> aList = new ArrayList<List<Number>>();

Même si c'est OK:

List<? extends Number> aList = new ArrayList<Number>();

Compilateur message d'erreur est:

Type mismatch: cannot convert from ArrayList<List<Number>> to List<List<? extends Number>>

InformationsquelleAutor | 2009-04-14

generics java

73

En Java, si Car est une classe dérivée de Vehicle, alors nous pouvons traiter toutes les Cars comme Vehicles; un Car est un Vehicle. Cependant, un List de Cars n'est pas un List de Vehicles. Nous disons que List<Car> est pas covariante avec List<Vehicle>.

Java vous oblige à indiquer explicitement lorsque vous souhaitez utiliser la covariance et la contravariance avec des caractères génériques, représentée par le ? jeton. Jetez un oeil à où votre problème se pose:
```
List<List<? extends Number>> l = new ArrayList<List<Number>>();
//       ----------------                          ------
//
//"? extends Number" matched by "Number". Success!
```
L'intérieur List<? extends Number> fonctionne parce que Number en effet, d'étendre Number, de sorte qu'il correspond à "? extends Number". Pour l'instant, donc bon. Quelle est la prochaine?
```
List<List<? extends Number>> l = new ArrayList<List<Number>>();
//  ----------------------                    ------------
//
//"List<? extends Number>" not matched by "List<Number>". These are
//  different types and covariance is not specified with a wildcard.
//  Failure.
```
Cependant, la combinaison intérieure paramètre de type List<? extends Number> n'est pas compensée par List<Number>; les types doivent être exactement identiques. Un autre joker dira Java que ce type doit également être covariants:
```
List<? extends List<? extends Number>> l = new ArrayList<List<Number>>();
```
- Un exemplaire de l'explication, en effet. +1
- Semble comme List<List<? s'étend Nombre>> LHS permettrait de mieux correspondre à l'affiche de l'intention.
InformationsquelleAutor John Feminella
3

Je ne suis pas très familier avec la syntaxe Java, mais il semble que votre question est: est-ce

La Covariance et la Contravariance

InformationsquelleAutor eulerfx
3

Vous devriez certainement utiliser l' ? type générique lorsque cela est approprié, ne pas éviter, en règle générale. Par exemple:
```
public void doThingWithList(List<List<? extends Number>> list);
```
vous permet de passer un List<Integer> ou un List<Long>.
```
public void doThingWithList(List<List<Number>> list);
```
permet de passer des arguments a déclaré que List<Number>. Une petite distinction, oui, mais en utilisant le caractère générique est puissant et sûr. Contrairement à la façon dont il peut sembler, une List<Integer> n'est pas une sous-classe, ou n'est pas cessible, de List<Number>. Ni List<Integer> une sous-classe de List<? extends Number, c'est pourquoi le code ci-dessus ne compile pas.

InformationsquelleAutor Steve Reed
2

Votre déclaration ne compile pas car List<? extends Number> n'est pas du même type que List<Number>. Le premier est un supertype de ce dernier.

Avez-vous essayé? Ici, je suis en exprimant que la Liste est covariant dans son argument de type, de sorte qu'il accepte n'importe quel sous-type de List<? extends Number> (qui comprend List<Number>).
```
List<? extends List<? extends Number>> aList = new ArrayList<List<Number>>();
```
Ou même ce. Ici, le paramètre de type de la liste de tableaux sur le côté droit est le même que le paramètre type sur le côté gauche, de sorte que la variance n'est pas un problème.
```
List<List<? extends Number>> aList = new ArrayList<List<? extends Number>>();
```
Vous devriez être en mesure de dire simplement
```
List<List<Number>> aList = new ArrayList<List<Number>>();
```
J'ai tendance à éviter les ? type génériques chaque fois que possible. Je trouve que les frais engagés dans le type d'annotation n'est pas la peine de la prestation.
- Ces deux suggestions de travail, mais cela n'explique toujours pas le fait que la déclaration d'origine ne fonctionne pas.
InformationsquelleAutor Apocalisp

-2

List<List<? extends Number>> aList = new ArrayList<List<? extends Number>>();
aList.add(new ArrayList<Integer>());

InformationsquelleAutor Alex

Vous devez vous connecter pour publier un commentaire.