L'ajout d'un écouteur à une variable en Java/JavaFX qui est appelée sur le changement de variable

Je sais qu'il y a des écouteurs dans JavaFX, et je suis sûr que Java. Mais je suis confus que sur la façon de les mettre en œuvre.

J'ai une variable booléenne qui est changé tout au long de mon programme. Chaque fois que le booléen est changé, je veux une fonction mafonction() pour être exécuté.

Cela peut être fait facilement?

Pourriez-vous nous montrer un peu de code? Je ne pense pas que ce que vous me demandez, c'est possible, mais le même effet peut être accompli d'une manière différente.

OriginalL'auteur CREW | 2012-04-01

4

Aussi simple que cela:
```
public void changeBooleanFlag(boolean bEnabled)
{
    if(booleanFlag == bEnabled) return;
    booleanFlag = bEnabled;
    myFunc();
}
```
et à chaque fois que vous voulez changer le drapeau booléen, vous devrait le faire via cette méthode.

Si vous utilisez cette réponse de la solution, et si vous accédez à cette procédure à partir de plusieurs threads, vous voulez certainement à mettre en œuvre certaines mécanisme de synchronisation.

OriginalL'auteur Eng.Fouad

Si vous utilisez JavaFX 2 ensuite, il fournit un out-of-box des solutions pour les deux composants JavaBeans architecture et le design pattern Observateur. En outre, il donne une grande souplesse d'associer l'état des variables par l'établissement des liaisons. Le code ci-dessous illustre la propriété a changé les événements et la liaison de la propriété des variables. Bien sûr, vous pouvez envelopper les accesseurs de propriété pour masquer les détails comme getFlag() et setFlag() ci-dessous, et de les utiliser dans le reste de l'application.

public class Demo extends Application {
private BooleanProperty booleanProperty = new SimpleBooleanProperty(true);
public static void main(String[] args) {
launch(args);
}
@Override
public void start(Stage primaryStage) {
//Add change listener
booleanProperty.addListener(new ChangeListener<Boolean>() {
@Override
public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
System.out.println("changed " + oldValue + "->" + newValue);
myFunc();
}
});
Button btn = new Button();
btn.setText("Toggle boolean flag");
btn.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
booleanProperty.set(!booleanProperty.get()); //toggle
System.out.println("toggled to " + booleanProperty.get());
}
});
//Bind to another property variable
btn.underlineProperty().bind(booleanProperty);
StackPane root = new StackPane();
root.getChildren().add(btn);
primaryStage.setScene(new Scene(root, 300, 250));
primaryStage.show();
}
public boolean getFlag() {
return booleanProperty.get();
}
public void setFlag(boolean val) {
booleanProperty.set(val);
}
}

OriginalL'auteur Uluk Biy

Je voudrais le faire en utilisant PropertyChangeListener. Voici un bon tutoriel: http://docs.oracle.com/javase/tutorial/uiswing/events/propertychangelistener.html

Exemple de code:

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.List;
public class MyClass {
private final List<PropertyChangeListener> listeners = new ArrayList<>();
private boolean b1, b2;
public MyClass() {
}
public boolean isB1() {
return b1;
}
public void setB1(boolean b1) {
boolean oldValue = this.b1;
this.b1 = b1;
firePropertyChange("b1", oldValue, b1);
}
public boolean isB2() {
return b2;
}
public void setB2(boolean b2) {
boolean oldValue = this.b2;
this.b2 = b2;
firePropertyChange("b2", oldValue, b2);
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
listeners.add(listener);
}
private void firePropertyChange(String property, Object oldValue, Object newValue) {
for (PropertyChangeListener l : listeners) {
l.propertyChange(new PropertyChangeEvent(this, property, oldValue, newValue));
}
}
/**
* Main method for tests.
* @param args
*/
public static void main(String[] args) {
MyClass m = new MyClass();
m.addPropertyChangeListener(new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent e) {
String changedProperty = e.getPropertyName();
System.out.println("Changed property: " + changedProperty);
System.out.println("New value: " + e.getNewValue());
System.out.println("Old value: " + e.getOldValue());
System.out.println();
}
});
m.setB1(true);
m.setB2(false);
}
}

OriginalL'auteur ceklock

U pouvez utiliser le design pattern Observateur.
Tout comme ce：

 public interface Listener
{
public void handle(Object o) ;
}
public class PropertiesChangeListener
{
public void handle(Object o) {
//DO SOMETHING...
}
}
public class Bean {
private boolean flag;
private List<Listener> listeners = new ArrayList<Listener>();
public setFlag(boolean flag) {
this.flag = flag;
if (listeners.size() > 0 ) {
for (Listener l : this.listeners ) {
l.handle(flag); //invoke 
}
}
}
public registerListener(Listener listener) {
this.listeners.add(listener);
}
//..... other fields and methods
}
public class Main{
public static void main(String[] args) {
Bean bean  = new Bean();
bean.registerListener(new PropertiesChangeListener());
bean.setFlag(true); //handler method will be invoked..
}
}

OriginalL'auteur Joey

0

Il y a 2 solutions pour votre problème
1. À l'aide de la plaine de Java, dans ce cas, vous devez ajouter des écouteurs à votre bean (par vous-même) et ensuite invoquer les méthodes d'écoute sur la méthode de définition (par vous-même), et de faire de la variable privé, de sorte qu'il ne peut être modifié par votre méthode d'initialisation.
2. La deuxième solution est d'utiliser un pur AOP cadre (je sais AspectJ peut le faire), ce qui peut intercepter la modification de la variable, puis appelez votre écouteur à l'aide de l'un des aspects. J'en mentionnerai que l'utilisation de @AspectJ (annotation support d'AspectJ), vos aspects purement pour des classes Java, et il n'est pas nécessaire pour une AspectJ soutien IDE.
Pour plus d'informations sur la première solution regarder JavaBeans Spécifications et des échantillons.

OriginalL'auteur Amir Pashazadeh

Vous devez vous connecter pour publier un commentaire.