Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 6 sur 6
  1. #1
    Membre régulier
    Homme Profil pro
    Inscrit en
    septembre 2002
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations forums :
    Inscription : septembre 2002
    Messages : 205
    Points : 97
    Points
    97

    Par défaut Question grammaire – Signification des "< >" dans les déclarations

    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 ?
    le problème se situe souvent entre la chaise et le clavier.
    @@++

  2. #2
    vinou92340
    Invité(e)

    Par défaut

    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

  3. #3
    Membre régulier
    Homme Profil pro
    Inscrit en
    septembre 2002
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations forums :
    Inscription : septembre 2002
    Messages : 205
    Points : 97
    Points
    97

    Par défaut

    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 !
    le problème se situe souvent entre la chaise et le clavier.
    @@++

  4. #4
    vinou92340
    Invité(e)

    Par défaut

    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à.
    Dernière modification par vinou92340 ; 26/12/2012 à 10h41.

  5. #5
    Expert Confirmé Sénior
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    avril 2002
    Messages
    13 310
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Java/Web
    Secteur : Transports

    Informations forums :
    Inscription : avril 2002
    Messages : 13 310
    Points : 21 535
    Points
    21 535

    Par défaut

    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++

  6. #6
    Membre régulier
    Homme Profil pro
    Inscrit en
    septembre 2002
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations forums :
    Inscription : septembre 2002
    Messages : 205
    Points : 97
    Points
    97

    Par défaut

    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.
    le problème se situe souvent entre la chaise et le clavier.
    @@++

+ Répondre à la discussion
Cette discussion est résolue.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •