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.


SommairePropriétésBinding de bas niveau (3)
précédent sommaire suivant
 

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
    2
    final 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.

Mis à jour le 29 septembre 2014 bouye

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.

Mis à jour le 29 septembre 2014 bouye

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>
Il n'existe pas de classes de binding dédiées pour les types byte, char et short.

Mis à jour le 29 septembre 2014 bouye

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 ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les 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 © 2017 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.

 
Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -