Is it a good practice to have static final field DUMMY in interfaces used as listeners? Often I have to write classes implementing listener interfaces with empty methods bodies.

For example:

MyOnClickListener .java

public interface MyOnClickListener {
    void onClick();
}


and 

MyDummyOnClickListener .java

public class MyDummyOnClickListener implements MyOnClickListener {
    public void onClick() {
        // skip
    }
}


Maybe it would be better to have a static final field DUMMY in each such an interface?

MyOnClickListener .java

public interface MyOnClickListener {
    void onClick();

    public static final MyOnClickListener DUMMY = new MyOnClickListener() {
        public void onClick() {
            // skip
        }
    }
}


So I need only 1 .java class, and each time when I change interface I don't have to find and open another .java class with "dummy" implementation.

What do you think? What are the disadvantages of such a solution?
A common pattern to avoid these instances is to create a 'default' abstract class for the interface. One that comes to mind is the SAX parser's DefaultHandler

Consider an abstract class (marked abstract even though it implements the method):

public abstract class DefaultOnClickListener implements MyOnClickListener {
    public void onClick() {
        // override to implement
    }
}


Now, you can extend the class, and chose to change the behaviour, by overriding the method, or leaving the default behaviour, by not overriding the method.

This solution means that the dummy implementations are only in one place.