Question grammaire – Signification des "< >" dans les déclarations [Résolu]

[Seboubou86]

Bonjour,

J’ai une question de grammaire Java. Je suis en train d’étudier un peu JavaFX, et je viens de découvrir une syntaxe que je ne comprends pas très bien. Voici un exemple :

Code :

1
2
3
objet.setOnMouseClicked(new EventHandler<MouseEvent>(){
...
});

J'ai bien compris l'utilité de cette fonction et je serais capable de la réutilisé. Ce que je ne comprend pas c'est l'usage du "<...>".

Voici d'autres exemples d'utilisation des "<...>" :

Code :

1
2
public TableCell<S, T> call(TableColumn<S, T> p) {
...}

et encore

Code :

ObservableList<Person> data = tableView.getItems();

Pour ce dernier exemple, je pense que "<Person>", sert à préciser l'objet utilisé dans une collection.



Quelqu'un pourrait-il éclairer ma lanterne ?

Ouaip, Person est la classe des objets contenus dans la collection.
Pour tableCell<S,T> , je t invite à aller voir ce lien pour le cas tableColumn où S et T sont détaillés :

http://docs.oracle.com/javafx/2/api/...bleColumn.html

Sauf que dans le cas d une cellule, T devient:
The type of the item contained within the Cell.

Voila chef

[Seboubou86]

Merci pour cette réponse !

En fait ma question était d'ordre générique au niveau du langage java !

Que veulent dire ces deux caractère ? L idée étant de comprendre et de pouvoir le reproduire !

En gros en java, c est généralement tout simplement le type d objets (donc la classe) contenus par exemple dans les collections et plus généralement dans tout conteneur (ex: tout ce qui s apparente à java.util.arraylist, set, list,...).
Après, rien ne t'empêche de mettre <Object> et de mettre des objets de type différent. Cependant, il faudra les convertir lors de la récupération dans le bon type. Voilà.

[adiGuba]

Salut,


Il s'agit des "types paramétrés", aussi nommées "Generics".

Lorsque tu définis une classe, tu peux lui associé un ou plusieurs types paramétrés, que tu pourras réutiliser partout ailleurs dans cette même classe.

Par exemple prenons la classe suivante :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MyType {
 
    private Object value;
 
    public MyType() {
 
    }
 
    public void setValue(Object value) {
        this.value = value;
    }
 
 
    public Object getValue() {
        return this.value;
    }
 
}

Le problème lorsque tu utilises cette classe, c'est que tout passe par objet et que rien n'est vérifié à la compilation. Il te faut rajouter des cast pour faire compiler le code.
Le problème c'est que du coup il n'est pas sûr, si tu fais ceci par exemple :

Code :

1
2
3
4
5
MyType t = new MyType();
t.setValue( new Integer(0) );
 
Integer i = (Integer) t.getValue(); // OK mais cast obligatoire
Double d = (Double) t.getValue(); // => ClassCastException

Le code compile normalement et sans warning/erreur, mais tu aura une ClassCastException à l'exécution (car "value" est un Integer alors que tu le cast en Double).




Pour éviter cela on va rajouter un type paramétré à la classe, ce qui nous donne le code suivant (par convention les types paramétrés sont composé d'une seule lettre en majuscule)

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MyType<V> {
 
    private V value;
 
    public MyType() {
 
    }
 
    public void setValue(V value) {
        this.value = value;
    }
 
 
    public V getValue() {
        return this.value;
    }
 
}

Lorsqu'on écrit "MyType", on ne connait pas le type paramétré, mais on sait juste que le type "V" sera le même pour une même instance.

Du coup désormais lorsqu'on va utiliser notre objet "MyType", il faudra préciser le type, par exemple :

Code :

1
2
3
MyType<String> t = new MyType<String>();
// Ou depuis Java 7 avec l'inférence de type :
MyType<String> t = new MyType<>();

Le compilateur saura alors que le paramètre "V" correspond en fait au type "String", et il pourra alors effectuer des vérifications supplémentaire quand à la validité des paramètres.

Si on reprend le code précédent, on n'a plus besoin de caster, et même si on fait un cast incorrect le compilateur pourra nous le signaler dès la compilation (ce qui permet d'éviter de faire passer des erreurs involontaires) :

Code :

1
2
3
4
5
MyType<Integer> t = new MyType<Integer>();
t.setValue( new Integer(0) );
 
Integer i = t.getValue(); // OK, cast inutile
Double d = (Double) t.getValue(); // => Erreur de compilation

Il y a plein d'autres spécificités et cas d'utilisation, mais en clair les Generics permettent un code plus sécurisé, en indiquant au compilateur les types avec lesquels on souhaite travailler.





Plus d'info ici : http://lroux.developpez.com/article/...ge_5#Lgenerics

a++

[Seboubou86]

Merci adiGuba !

Tu as vraiment bien répondu à ma question. Je vais lire le tutoriel de Lroux sur les générics pour approfondire ma connaissance de cet outil.