IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage Java Discussion :

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


Sujet :

Langage Java

  1. #1
    Membre habitué

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2002
    Messages
    207
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : Suisse

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Septembre 2002
    Messages : 207
    Points : 133
    Points
    133
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    public TableCell<S, T> call(TableColumn<S, T> p) {
    ...}
    et encore

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 ?
    @@++

  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 habitué

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2002
    Messages
    207
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : Suisse

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Septembre 2002
    Messages : 207
    Points : 133
    Points
    133
    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 !
    @@++

  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 à 11h41.

  5. #5
    Expert éminent sénior
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    Avril 2002
    Messages
    13 938
    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 938
    Points : 23 190
    Points
    23 190
    Billets dans le blog
    1
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 habitué

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2002
    Messages
    207
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : Suisse

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Septembre 2002
    Messages : 207
    Points : 133
    Points
    133
    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.
    @@++

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

Discussions similaires

  1. Réponses: 15
    Dernier message: 29/10/2006, 19h01
  2. Réponses: 3
    Dernier message: 20/09/2006, 23h35

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo