FAQ JavaFXConsultez toutes les FAQ
Nombre d'auteurs : 4, nombre de questions : 507, dernière mise à jour : 2 novembre 2016 Ajouter une question
Cette FAQ a été réalisée à partir des questions fréquemment posées sur le forum JavaFX de http://java.developpez.com ainsi que l'expérience personnelle des auteurs.
Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.
Sur ce, nous vous souhaitons une bonne lecture.
Pour créer un binding de bas niveau, il faut étendre une des classes abstraites qui héritent de l'interface javafx.beans.binding.Binding et surcharger sa méthode computeValue(). Il faut également lier ce nouvel objet avec les propriétés qui lui servent de source et grâce auxquelles il va pouvoir calculer sa valeur en utilisant sa méthode bind().
Reprenons notre équation simple, par exemple :
Code : | Sélectionner tout |
w = 5 * x + y / z
Ici, x, y et z sont des propriétés dont la valeur peut changer au fil du temps. Et nous voulons que tout changement sur une de ces trois propriétés invalide immédiatement w.
Nous avons précédemment effectué ce calcul en utilisant le binding de haut niveau, mais nous avons vu que cela crée une expression peu lisible et qui surtout instancie plein de petits objets intermédiaires.
Nous allons créer un nouveau binding, mais de bas niveau cette fois, qui prend en charge le même calcul :
Code Java : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | public class WEquation extends DoubleBinding { private final ObservableDoubleValue obsersableX; private final ObservableDoubleValue obsersableY; private final ObservableDoubleValue obsersableZ; public WEquation(ObservableDoubleValue x, ObservableDoubleValue y, ObservableDoubleValue z) { this.obsersableX = x; this.obsersableY = y; this.obsersableZ = z; // W observe désormais les valeurs de x, y et z. bind(obsersableX, obsersableY, obsersableZ); } @Override public void dispose() { // Quand w est disposée, nous n'avons plus besoin de maintenir la liaison vers x, y et z. unbind(obsersableX, obsersableY, obsersableZ); super.dispose(); } @Override protected double computeValue() { // Si w est invalidée (après la création ou parce que x, y ou z a été modifié), on recalcule la valeur. // Cette méthode n'est invoquée que si on accède à la valeur dans la propriété. double x = obsersableX.get(); double y = obsersableY.get(); double z = obsersableZ.get(); return 5 * x + y / z; } } |
Que nous pouvons utiliser de cette manière :
Code Java : | Sélectionner tout |
1 2 3 4 | final DoubleProperty x = new SimpleDoubleProperty(); final DoubleProperty y = new SimpleDoubleProperty(); final DoubleProperty z = new SimpleDoubleProperty(); final WEquation w = new WEquation(x, y, z); |
Initialement, à sa création, la valeur de w n'a pas encore été évaluée. Sa méthode isValid() retourne la valeur false.
La valeur de w est immédiatement évaluée si :
- on utilise un de ses getters. Par exemple :
Code Java : Sélectionner tout System.out.printf("W: %f", w.get()).println();
- on lui ajoute un écouteur. Par exemple :
Code Java : Sélectionner tout w.addListener(observable -> System.out.println("W invalidée"));
- on lie une autre expression ou propriété sur elle. Par exemple :
Code Java : Sélectionner tout 1
2final DoubleProperty v = new SimpleDoubleProperty(); v.bind(w);
Ici, étant donné le calcul effectué et puisque x, y et z sont toutes trois initialisées à 0, le résultat du calcul est NaN.
Par contre, si nous faisons :
Code Java : | Sélectionner tout |
1 2 3 | z.set(2); y.set(10); x.set(8); |
Le premier changement de valeur de propriété invalide également la valeur de w. Cependant, la valeur de w n'est réévaluée que lorsque nous la récupérons en invoquant getter ou par un ChangeListener.
Si nous faisons :
Code Java : | Sélectionner tout |
w.addListener(observable -> System.out.printf("W: %f", w.get()).println());
Ici, nous avons ajouté un écouteur de type InvalidationListener, mais comme nous accédons au getter, la propriété est réévaluée à chaque fois que la valeur de x, y ou z change.
Oui bien sûr. Dans notre exemple ci-dessus, nous avons utilisé trois propriétés de type ObservableDoubleValue comme propriété source pour notre binding. Mais ce n'est pas obligatoire : nous aurions pu faire que z soit, par exemple, une ObservableStringValue, ce qui nous aurait obligé à parser une chaine de caractères en double lors du calcul.
L'important ici est que la méthode computeValue() effectue le bon calcul et retourne le bon type et ce quelles que soient les sources utilisées.
Voici donc un tableau récapitulatif des diverses classes à utiliser selon le type de la valeur à calculer dans un binding de bas niveau :
Valeur à calculer dans computeValue() | Type à retourner dans computeValue() | Binding à étendre |
Valeurs booléennes | boolean | BooleanBinding |
Nombres entiers | int | IntegerBinding |
Nombres flottants | float | FloatBinding |
Nombres entiers longs | long | LongBinding |
Nombres flottants en double précision | double | DoubleBinding |
Chaines de caractères | String | StringBinding |
Objets quelconques | T | ObjectBinding<T> |
Listes observables | ObservableList<T> | ListBinding<T> |
Ensembles observables | ObservableSet<T> | setBinding<T> |
Tables de hachage observables | ObservableMap<T> | MapBinding<T> |
Proposer une nouvelle réponse sur la FAQ
Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour çaLes sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.