Re: Events-am I missing something?

A lot of people have already weighed in on this, but I thought I'd kick in
my $0.02.

Events in Java are "design patterns". Java provides a couple of specific
features (java.util.EventObject), and makes good use of interfaces to
implement the events pattern. There is very little else in the way of object
or language support. Programmers are expected to follow standard design
patterns and naming conventions to implement event sources and event
listeners.

The Java Beans specification
(http://java.sun.com/javase/technologies/desktop/javabeans/docs/spec.html)
describes the events design pattern and shows some typical ways of
implementing event listeners and event sources. The original Java Beans spec
showed (and the current version still shows) event sources implemented using
Vector to hold the registered listeners. Today, I typically use a
synchronized ArrayList to hold my listeners. It allows me to do this
(without having to explicitly synchronize my methods -- the relevant calls
into ArrayList are synchronized for me):

    /** List of registered listeners. */
    private List<IServiceListener> m_listeners =
        Collections.synchronizedList(new ArrayList<IServiceListener>());

    /**
     * Standard design pattern registers a new service listener.
     * @param listener to add.
     */
    public void addListener(IServiceListener listener) {
        m_logger.config(listener.toString());
        m_listeners.add(listener);
    }

    /**
     * Standard design pattern unregisters a service listener.
     * @param listener to remove.
     */
    public void removeListener(IServiceListener listener) {
        m_logger.config(listener.toString());
        m_listeners.remove(listener);
    }

        /**
         * Event Source. Fires data changed event when data is added.
         * @param event contains the data being added.
         */
        public void dataAdded(DataEvent event) {
            IServiceListener[] listeners =
                m_listeners.toArray(new
IServiceListener[m_listeners.size()]);

            for (IServiceListener listener : listeners) {
                try {
                    listener.dataChanged(event);
                } catch (Exception warning) {
                    m_logger.warning(toMessage(warning));
                    m_listeners.remove(listener);
                }
            }
        }

In many respects, events (in Java and other environments, such as
ActiveX/COM/.net) are simply glorified callback mechanisms to which you can
register for notification that something happened, e.g., an asynchronous
process completed. The Java event design patterns simply helps everyone do
things approximately the same way, and the naming conventions help tools
discover and use the event facilities of an object through
reflection/introspection.