syntaxe java incompréhensible

Bonsoir à tous

j'ai un problème concernant la compréhension de quelques aspects de la syntaxe java que je trouve dans l'exemple suivant:

Code:

---

addAll(Collection<? super T> c, T... elements)

---

mon problème n'est pas dans ce que fait cette méthode qui ajoute des élément à une liste, mais la signification des caractères "<?", "super T> c" et de "T... elements"
j'ai vraiment pas compris le point d’interrogation, le signe inférieur ou supérieur que je trouve aussi dans d'autre exemples

merci pour votre aide

Salut,


Dans un premiers temps il faut comprendre qu'il s'agit d'un méthode paramétré par un type T dont on ne connait pas le type exact au moment où l'on a écrit la méthode, mais qui sera déterminé à l'utilisation.

Collection<T> correspond alors à une collection d'objet de type T précisément.
Collection<? super T> correspond alors à une collection de n'importe quel objet parent du type T (ou le type T lui même)

Par exemple si T est un Integer, alors Collection<T> représentera obligatoirement un Collection<Integer> et rien d'autre.
Par contre Collection<? super T> représente n'importe quelle collection pouvant accueillir des objets de type T, donc dans ce cas Collection<Integer>, Collection<Number> ou même Collection<Object>...

Cela permet de ne pas trop contraindre le type de la liste inutilement.


Quand aux "T... elements" c'est une l'ellipse, et c'est équivalent à utiliser un tableau en paramètre : T[] elements.
La seule différence c'est que c'est le compilateur qui se chargent de créer le tableau, et qu'on utilise la méthode comme si elle avait un nombre variable de paramètres.
Exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public void method1(String[] args) { ... }   public void method2(String...args) { ... }   method1("a"); method1("a", "b"); method1("a", "b", "c"); method1("a", "b", "c", "d");     method2(new String[]{"a"}); method2(new String[]{"a", "b"}); method2(new String[]{"a", "b", "c"}); method2(new String[]{"a", "b", "c", "d"});

---

a++

Edit : je n'avais pas vu la réponse d'adiGuba, plus claire et plus concise que la mienne... :-(

Bonjour,
même si tu connais le rôle de addAll, il est important de le rappeler pour mieux comprendre les concepts utilisés, et les symboles permettant de les mettre en oeuvre.

Citation:

---

public static <T> boolean addAll(Collection<? super T> c, T.. a)

---

permet d'ajouter des éléments a, à une collection c.

Les paramètres variables T... a :
T... a permet de spécifier une suite d'arguments variables de type T (varArgs). T... a sera analysé comme un tableau d’éléments de type a T[] a. Cette déclaration n'est possible que sur le dernier paramètre, qui sera interprété comme T[] a. A la différence près que l'appel peut se faire sans utiliser de tableau :

On utilise addAll comme une méthode à nombre de paramètres variable, sans avoir besoin de lui passer un tableau :

Code:

---

1 2 3 4 5

ArrayList<Number> desNombres=new ArrayList<>(); ... Collections.addAll(desNombres, 1,2,3,4); Collections.addAll(desNombres, 5,6);

---

pas besoin de :
Collections.addAll(desNombres, new Integer[]{1,2,3,4});

La généricité (depuis java 5) :

<T> permet de mettre en oeuvre la généricité (ou polymorphisme paramétrique) :
pour faire court, la généricité permet d'introduire des paramètres formels de type, déclarés entre chevrons (<type>) dans la déclaration des classes.
Elle évite l'utilisation systématique du cast (et ses erreurs à l'exécution) et permet d'imposer des contraintes de type, vérifiées à la compilation.

Exemple de déclaration de classe générique :

Code:

---

1 2 3 4 5 6

public class Bar<A> { // asA retourne une instance du type générique A public A asA(B aB) { ... } }

---

A l'utilisation, si on crée une instance de Bar paramétrée avec un String, on pourra utiliser le retour de la méthode asA comme un String :

Code:

---

1 2 3

Bar<String> aBar=new Bar<>(); String s=aBar.asA(new B()).subString(0,2);

---

Généricité avec Jocker et contrainte : <?>
Le jocker ? fait référence à un type quelconque.
<? extends A> fait référence à un type générique dérivant de la classe A

Exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10

public class Bar<A> { // asA retourne une instance du type générique A public A asA(B aB) { ... } // asBarDerive retourne une instance d'un type dérivé du type générique A public Bar<? extends A> asBarDerive() { ... } }

---

A l'inverse, <? super A> permet de faire référence à un type super-classe (parent) de A.

Pour en revenir au addAll :

Citation:

---

public static <T> boolean addAll(Collection<? super T> c, T.. a)

---

On ne peut ajouter des éléments dans une collection, que si le type des éléments à ajouter est assignable au type générique des éléments de la collection.
Dans une collection de Number par exemple, tu peux ajouter des instances de Number, et de ses classes dérivées : Integer, Long, Double, Short...

Code:

---

1 2	ArrayList<Number> desNombres=new ArrayList<>(); Collections.addAll(desNombres, 1,2,3,4,12l,5.2,3f,new BigDecimal("1.234"));

---

Le type des éléments à ajouter est T, et le type des éléments de la collection doit être un sur-type de T : <? super T>

Merci à vous deux pour les précisions si précieuses

mais pour le dernier exemple vous dites

Citation:

---

Le type des éléments à ajouter est T, et le type des éléments de la collection doit être un sur-type de T : <? super T>

---

par contre vous présentez le type "number" qui est un super type des autres et non un sous types.



autre chose conernant le caratère ? j'ai trouvé une autre utilisation qui n'est pas la même

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

public class TagSet { ... protected HashSet<String> whiteList; protected boolean caseSensitive = true; .... public boolean isTagToProcess(String tag) { return whiteList.contains( caseSensitive ? tag : tag.toUpperCase()); } ..... }

---

j'arrive pas à comprendre cette instruction et l'effet du "?" et des deux points ":"

Code:

---

return whiteList.contains(caseSensitive ? tag : tag.toUpperCase());

---

merci d'avance

Citation:

---

Le type des éléments à ajouter est T, et le type des éléments de la collection doit être un sur-type de T : <? super T>

---

Oui, si tu as une collection de Number, tu peux y ajouter des éléments appartenant à ses sous-types : Number, Integer, Float, Double...et chacun des types des éléments à ajouter (Integer,Float...) doit bien avoir comme sur-Type Number, ou être exactement un number.

Citation:

---

return whiteList.contains(caseSensitive ? tag : tag.toUpperCase());

---

Ici, l'utilisation du ? n'a rien à voir avec la généricité, c'est la contraction du si-alors-sinon :

variable=condition ? resultatSiVrai : resultatSifaux ;
Si condition est vraie, resultatSiVrai est affecté à variable et resultatSifaux dans le cas contraire


Pour ton code, un équivalent non contracté serait :

Code:

---

1 2 3 4 5 6 7 8

String cTag; if(caseSensitive){ cTag=tag; }else{ cTag=tag.toUpperCase(); } return whiteList.contains(cTag);

---

C'est à utiliser avec modération, pour ne pas nuire à la lisibilité du code :

Code:

---

1 2 3 4 5 6 7 8 9

if (a<b){ min=a; } else { min=b; } //équivaut à : min = a<b ? a : b;

---