Java-PropertyChangeListener

Question

I saw an ex. using the following for a class:

 private static PropertyChangeListener listener = new PropertyChangeListener() {
 @Override
public void propertyChange(PropertyChangeEvent event) { 
    // Method definition
}
}

1) My first question is that how it could instantiate an interface?

 java.beans: Interface PropertyChangeListener

2) In most examples I've seen, they add PropertyChangeSupport() like following:

 public class MyClass{
private PropertyChangeSupport pcs;

public MyClass(PropertyChangeListener listener) {

    pcs = new PropertyChangeSupport(this);
    pcs.addPropertyChangeListener(listener);
}       

public void method() {
    if (condition) {
        pcs.firePropertyChange();
    }
}

}

In my class, the method is an static method instead.

I did not see in any examples, PropertyChangeSupport defined as static variable and am not sure its right thing to do?

Does it have any performance issue b/c its going to observe all static variables of the class?

Although firePropertyChange() is fired only for one of the variables.

This is how I use it:

 public class MyClass{
private static PropertyChangeSupport pcs = new PropertyChangeSupport(MyClass.class);

public static void method(PropertyChangeListener listener) {

    pcs.addPropertyChangeListener(listener);

    if (condition) {
        pcs.firePropertyChange();
    }
}
 }

My class used to be like this, but this method is called many times and I don't want to create a new pcs object every time I call this method, so I changed it like above - define as static variable instead - not sure which practice is better.

 public class MyClass{  

public static void method(ConcurrentMap map, PropertyChangeListener listener) {

            // pcs is defined to observe only map.
    PropertyChangeSupport pcs = new PropertyChangeSupport(map);

    pcs.addPropertyChangeListener(listener);

    if (condition) {
        pcs.firePropertyChange();
    }
}

}

Any help is greatly appreciated.

Answer 1

The first example is possible because you define an anonymus inner class that implemnets the interface.

For the rest it is not clear what ProperyChangeSupport is

I would recomend using the ObserverPattern http://en.wikipedia.org/wiki/Observer_pattern

so it would look something like this

public MyClass implements PropertyChangeSupport {

    private List<PropertyChangeListener> listener;

    public void addPropertyChangeListener(PropertyChangeListener) {
        //add the listener
    }

    public void firePropertyChange() {
        //Handle the property change and iterate over all the listener
        for(PropertyChangeListener l: listener) {
            l.propertyChange(new PropertyChangeEvent());
        }
    }

    public void someMethodThatChangesTheProperty() {
        //Do whatever you have to do
        this.firePropertyChange();
    }

}