How to create change listener for variable?

Question

Let's say I have some variable defined using the statementint someVariable;. While the code runs, the variable's value changes.

How can I track the changes in this variable? How could I implement some Listener that behaves like onSomeVariableChangedListener?

I also need to know when some other method in one page has been executed so I can set a Listener in another class.

Answer 1

Java gives you a simple Observer pattern implementation for this kind of thing, but you'll need to set your observed variable within a method that manages listener notifications. If you can't extend Observable, you can either use composition (i.e., have an Observable instance in your class to manage notifications), or you can take a look at java.util.Observable to get an idea of how to roll your own version.

Flux.java

import java.util.Observable;  public class Flux extends Observable {   private int someVariable = 0;    public void setSomeVariable(int someVariable) {     synchronized (this) {       this.someVariable = someVariable;     }     setChanged();     notifyObservers();   }    public synchronized int getSomeVariable() {     return someVariable;   } } 

Heraclitus.java

import java.util.Observable; import java.util.Observer;  public class Heraclitus implements Observer {   public void observe(Observable o) {     o.addObserver(this);   }    @Override   public void update(Observable o, Object arg) {     int someVariable = ((Flux) o).getSomeVariable();     System.out.println("All is flux!  Some variable is now " + someVariable);   } } 

Answer 2

This is one of the many reasons to hide variables behind setter/getter pairs. Then, in the setter you can notify your listener that this variable has been modified in the appropriate way. As the others have commented, there is no built in way to do exactly what you want, you need to implement it yourself.

Alternatively Benjamin brings up an interesting pattern, called the Decorator pattern, which might be useful to you if the code in question cannot be modified. You can look up more info at Wikipedia

The idea is to build a compatible wrapper around an object. Lets say your object in question is of type MyClass.

class MyClass{     public void doFunc(){...} }      class MyLoggedClass extends MyClass{     MyClass myObject;          public void doFunc(){         //Log doFunc Call         myObject.doFunc();     } } 

instead of

MyClass object = new MyClass(); 

You would use

MyClass object = new MyLoggedClass(new MyClass()); 

Now your rest of the code would use object as per normal, except that each function call will be logged, or notified, etc.

As you will see in Wikipedia, this is typically done via an interface that the class in question inherits from, but this may not be possible in your case.