Java Observers/Object Listeners (Game Engine)

Question

I'm working on a game engine, and the last question I had regarding this was what good way I can use to make "observers" or listeners. A user suggested that I should use Java's EventObject class to inherit from and make a Listener interface. However, this didn't provide me with good flexibility.

Here is the Handler annotation to state that a method is an event handler in a listener:

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.METHOD)
public @interface Handler {}

Here is the base class for Event, which is basically the same as EventObject (but I'll add abstract methods sooner or later):

public abstract class Event {

    private Object source;

    public Event(Object source) {
        this.source = source;
    }

    public Object getSource() {
        return source;
    }
}

Here is the Listener class, which is empty:

public interface Listener {}

Here is the ListenerHandler class, used to handle all listeners. You register and unregister them here. I'll edit the register/unregister methods later for a better use:

public class ListenerHandler {

    private ArrayList<Listener> listeners;

    public ListenerHandler() {
        this.listeners = new ArrayList<Listener>();
    }

    public void registerListener(Listener l) {
        listeners.add(l);
    }

    public void unregisterListener(Listener l) {
        listeners.remove(l);
    }

    public void onEvent(Event event) {
        for(Listener l : listeners) {
            Class<?> c = l.getClass();

            Method[] methods = c.getDeclaredMethods();

            for(Method m : methods) {
                if(m.isAccessible()) {
                    if(m.isAnnotationPresent(Handler.class)) {
                        Class<?>[] params = m.getParameterTypes();

                        if(params.length > 1) {
                            continue;
                        }

                        Class<?> par = params[0];

                        if(par.getSuperclass().equals(Event.class)) {
                            try {
                                m.invoke(this, event);
                            }catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }
}

From what I heard, it's a use of a lot of memory in order to get all methods of a class. I'm not going to assume this is the case, but I'm sure there is a better way as this will be a game engine with many components and such.

I'd like to know the best way to implement this, or if I'm doing it right. I'd also like to know if anyone can help me improve this in any way without hogging memory usage by the game (as of now it's not a big deal -- the "game engine" is not even close to rendering anything yet)

Answer 1

I tried to keep it a very simple example and will comment with different ideas to it: First meet the Achievement class:

import java.util.Observable;
    public class Achievement extends Observable {
    public static class AchievementDetails {}
public Achievement() {
        addObserver(EventsListener.getInstance());
    }
    public void achievementReached() {
        AchievementDetails achievemetDetails = null;
        setChanged();
        notifyObservers(achievemetDetails);
    }
}

And then the events listener class:

import com.test.Achievement.AchievementDetails;
public class EventsListener implements Observer {
    private static EventsListener instance = new EventsListener();
    public static EventsListener getInstance() {
        return instance;
    }
    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof Achievement) {
            AchievementDetails achievemetDetails = (AchievementDetails) arg;
            //do some logic here
        }
    }
}

The only one thing that is missing is to create an instance of your achievement (which register the EventsListener to itself) and handle the life cycle of it.