FAQ JavaFXConsultez toutes les FAQ

Une propriété est une valeur, un champ, dans un objet qui a ceci de spécifique qu'elle est observable : c'est-à-dire qu'elle émet des événements dès qu'elle est invalidée ou que sa valeur change. Ces événements peuvent être reçus par des observateurs qui ont placé un ou des écouteurs sur cette propriété.

Il est également possible de lier de diverses manières une propriété sur une ou plusieurs autres : quand la ou les propriétés sources sont modifiées, la valeur de la propriété cible est automatiquement réévaluée. C'est ce qu'on appelle le binding.

Bien que n'ayant absolument rien de graphique à la base, l'API de propriété constitue l'un des cœurs sur lesquels repose l'API JavaFX. Il est donc très important de bien comprendre ces notions avant d'essayer d'aborder l'utilisation de SceneGraph ou des nœuds graphiques.

JavaFX conserve la notation propre aux propriétés Java Beans donc vous accéderez aux propriétés d'un objet généralement via des getters et des setters comme vous en avez l'habitude. Cependant, il est de convention de fournir également une méthode supplémentaire qui permet d’accéder directement à l’objet propriété et ce, de manière à faciliter les opérations de binding ainsi que tout ce qui repose sur le mécanisme de la réflexion.

Récapitulons, pour une propriété JavaFX, nous avons :

• un getter - ex. : public String getName() ;
• un setter - ex. : public void setName(String value). Optionnel : on n'en fournit pas dans le cas d'une propriété en lecture seule ;
• un accesseur de propriété - ex. : public StringProperty nameProperty().
  

Quand la valeur d'une propriété change, cette dernière est marquée comme étant désormais non valide. Elle invalide également de fait toute autre propriété qui est liée sur elle via le binding. Les nouvelles valeurs de ces propriétés ne sont cependant pas calculées immédiatement : pour économiser des ressources, le calcul des nouvelles valeurs n'aura lieu que lors du prochain accès à la valeur de la propriété via un des getters.

Le binding est le fait de lier une propriété d'un objet à une ou plusieurs propriétés qu'on aurait définies ailleurs. Imaginons par exemple une propriété B que nous lions à une autre propriété A. La présence d'une liaison entre A et B fait que la valeur de B dépend de la valeur de A soit par une copie directe de la valeur, soit par un calcul ou une transformation quelconque qui va créer une nouvelle valeur à partir de celle de A.



L'API JavaFX propose deux types d’implémentation de binding :

• le binding de haut niveau - qui permet de faire du binding très simplement en utilisant les nombreuses classes et méthodes utilitaires fournies dans l'API JavaFX. Ceci peut cependant s’avérer gourmand en ressources et mémoire, voire pénible à écrire lorsqu'on veut établir des binding complexes (ex. : une équation contenant de nombreux variables et opérandes et qui se résoudrait automatiquement lorsqu'on saisit les valeurs de ses différents membres) ;
• le binding de bas niveau - qui permet de créer de nouveaux types de binding qui ne sont pas pris en charge par l'API JavaFX tout en conservant de bonnes performances.

Il s'agit d'un binding à sens unique sans transformation aucune : si une propriété B est liée sur une propriété A alors si la valeur de A change, la valeur de B change également et est égale à la valeur contenue dans A. Tant que la liaison perdure, il n'est pas possible de changer la valeur de B directement : tout essai lèverait une exception.

Il s'agit d'un binding dans les deux sens : si une propriété B est liée bidirectionnellement sur une propriété A alors si la valeur de A change, la valeur de B change également. Cependant si la valeur de B change, alors la valeur de A sera modifiée en retour. Ici aussi il n'y a pas de transformation de la valeur : les deux valeurs sont tout le temps égales entre elles.

Nous allons définir une propriété name contenant le nom d'une personne.

Commençons par définir le stockage de cette propriété en utilisant les classes fournies par l’API JavaFX : StringProperty et son implémentation concrète SimpleStringProperty.

private final StringProperty name = new SimpleStringProperty(this, "name");

1
2
3
public final String getName() { 
    return name.get(); 
}

1
2
3
public final void setName(final String value) { 
    name.set(value); 
}

1
2
3
public final StringProperty nameProperty() { 
    return name; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
private final StringProperty name = new SimpleStringProperty(this, "name"); 
  
public final String getName() { 
    return name.get(); 
} 
  
public final void setName(final String value) { 
    name.set(value); 
} 
  
public final StringProperty nameProperty() { 
    return name; 
}

Nous allons maintenant définir une propriété en lecture seule : c'est-à-dire qu'elle aura bien un getter, mais pas de setter et que l'objet propriété retourné ne permettra pas non plus de modifier la valeur contenue.

Nous allons créer une propriété age qui retourne l'âge de la personne. Comme nous pouvons calculer automatiquement l'âge en fonction de la date actuelle et de la date de naissance de la personne, il s'agit là typiquement d'une valeur que l'utilisateur ne doit pas pouvoir modifier.

Nous allons utiliser ici une classe wrapper : un objet qui empaquète une propriété et permet d'en avoir une version en lecture seule.

private final ReadOnlyIntegerWrapper age = new ReadOnlyIntegerWrapper(this, "age");

1
2
3
public final int getAge() { 
    return age.get(); 
}

1
2
3
public final ReadOnlyIntegerProperty ageProperty() { 
    return age.getReadOnlyProperty(); 
}

1
2
3
4
5
6
7
8
9
private final ReadOnlyIntegerWrapper age = new ReadOnlyIntegerWrapper(this, "age"); 
  
public final int getAge() { 
    return age.get(); 
} 
  
public final ReadOnlyIntegerProperty ageProperty() { 
    return age.getReadOnlyProperty(); 
}

Pour ce genre de propriétés, nous allons commencer exactement comme avec les propriétés en lecture seule, excepté que nous allons cette fois-ci créer un setter qui se chargera de faire les vérifications sur les valeurs saisies.

Créons une propriété childNumber qui est le nombre d'enfants à charge d'une personne. De toute évidence, ce nombre ne peut pas être négatif ; il peut être positif ou égal à 0 mais jamais négatif. Ce nombre peut cependant varier avec le temps : naissance, adoption, enfant qui devient majeur, perte de garde légale, décès…

Reprenons les bases de notre propriété en lecture seule :

1
2
3
4
5
6
7
8
9
private final ReadOnlyIntegerWrapper childNumber = new ReadOnlyIntegerWrapper(this, "childNumber ");  
  
public final int getChildNumber () {  
    return childNumber.get();  
}  
  
public final ReadOnlyIntegerProperty childNumberProperty() {  
    return childNumber.getReadOnlyProperty();  
}

1
2
3
4
5
6
public final void setChildNumber(final int value) throws IllegalArgumentException { 
    if (childNumber < 0) { 
        throw new IllegalArgumentException("Le nombre d'enfants à charge ne peut pas être négatif !");  
    } 
    childNumber.set(value); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private final ReadOnlyIntegerWrapper childNumber = new ReadOnlyIntegerWrapper(this, "childNumber ");  
  
public final int getChildNumber () {  
    return childNumber.get();  
}  
  
public final void setChildNumber(final int value) throws IllegalArgumentException { 
    if (childNumber < 0) { 
        throw new IllegalArgumentException("Le nombre d'enfants à charge ne peut pas être négatif !");  
    } 
    childNumber.set(value); 
} 
  
public final ReadOnlyIntegerProperty childNumberProperty() {  
    return childNumber.getReadOnlyProperty();  
}

Pour des raisons de performances et de gain en mémoire, il peut être intéressant de différer l'initialisation d'une propriété. Cette méthode peut être appliquée sur les propriétés qui sont peu souvent utilisées et part du principe qu'on a plus souvent l'occasion d'invoquer un getter qu'un setter ou un accesseur.

Ici nous allons stocker la propriété countryHouse, c'est-à-dire la résidence secondaire ou la maison à la campagne d'une personne.

Commençons par définir notre propriété :

private OjectProperty<House> countryHouse;

1
2
3
public final House getCountryHouse() { 
  return (countryHouse == null) ? null : coutryHouse.get(); 
}

1
2
3
public final void setCountryHouse(final House value) { 
    countryHouseProperty().set(value); 
}

1
2
3
4
5
6
public final OjectProperty<House> countryHouseProperty() { 
    if (countryHouse == null) { 
        countryHouse = new SimpleObjectProperty<>(this, "countryHouse"); 
    } 
    return coutryHouse; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private OjectProperty<House> countryHouse; 
  
public final House getCountryHouse() { 
  return (countryHouse == null) ? null : coutryHouse.get(); 
} 
  
public final void setCountryHouse(final House value) { 
    countryHouseProperty().set(value); 
} 
  
public final OjectProperty<House> countryHouseProperty() { 
    if (countryHouse == null) { 
        countryHouse = new SimpleObjectProperty<>(this, "countryHouse"); 
    } 
    return coutryHouse; 
}

Le nombre de classes dédiées au stockage des propriétés dans l'API JavaFX est important et peut donc être déroutant ou même décourager le programmeur débutant au premier abord.
Voici donc un tableau récapitulatif des diverses classes à utiliser selon le type de la valeur stockée :

Si votre propriété Java Bean est observable, oui c'est possible. Le package javafx.beans.property.adapter contient des classes définissant des monteurs (builder) qui permettent de créer des adaptateurs entre le monde Java Bean et le monde JavaFX.

Une propriété Java Beans est observable quand il est possible d'enregistrer un écouteur de type java.bean.PropertyChangeListener sur cette propriété.

Par exemple, créons une classe Person, notre bean, disposant d'une propriété age :

1
2
3
4
5
6
7
8
9
10
11
12
public class Person { 
  
  private int age = 30; 
  
  public int getAge() { 
    return age; 
  } 
  
  public void setAge(int age) { 
    this.age = age; 
  } 
}

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
32
public class Person { 
  
  private int age = 30; 
  
  public int getAge() { 
      return age; 
  } 
  
  public void setAge(int age) { 
      int oldAge = this.age; 
      this.age = age; 
      listenerList.firePropertyChange("age", oldAge, age); 
  } 
  
  private PropertyChangeSupport listenerList = new PropertyChangeSupport(this); 
  
  public void addPropertyChangeListener(PropertyChangeListener listener) { 
      listenerList.addPropertyChangeListener(listener); 
  } 
  
  public void removePropertyChangeListener(PropertyChangeListener listener) { 
      listenerList.removePropertyChangeListener(listener); 
  } 
  
  public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) { 
      listenerList.addPropertyChangeListener(propertyName, listener); 
  } 
  
  public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) { 
      listenerList.removePropertyChangeListener(propertyName, listener); 
  } 
}

1
2
3
4
fianl Person person = new Person(); 
final JavaBeanIntegerProperty personAge = JavaBeanIntegerPropertyBuilder.create() 
                                    .bean(person).name("age") 
                                    .build();