public synchronized void addComponentListener(ComponentListener l)
    public synchronized void removeComponentListener(ComponentListener l)
    public synchronized ComponentListener[] getComponentListeners()

    public synchronized void addFocusListener(FocusListener l)
    public synchronized void removeFocusListener(FocusListener l)
    public synchronized FocusListener[] getFocusListeners()

    public void addHierarchyListener(HierarchyListener l)
    public void removeHierarchyListener(HierarchyListener l)
    public synchronized HierarchyListener[] getHierarchyListeners()

    public void addHierarchyBoundsListener(HierarchyBoundsListener l)
    public void removeHierarchyBoundsListener(HierarchyBoundsListener l)
    public synchronized HierarchyBoundsListener[] getHierarchyBoundsListeners()

    public synchronized void addKeyListener(KeyListener l)
    public synchronized void removeKeyListener(KeyListener l)
    public synchronized KeyListener[] getKeyListeners()

    public synchronized void addMouseListener(MouseListener l)
    public synchronized void removeMouseListener(MouseListener l)
    public synchronized MouseListener[] getMouseListeners()

    public synchronized void addMouseMotionListener(MouseMotionListener l)
    public synchronized void removeMouseMotionListener(MouseMotionListener l)
    public synchronized MouseMotionListener[] getMouseMotionListeners()

    public synchronized void addMouseWheelListener(MouseWheelListener l)
    public synchronized void removeMouseWheelListener(MouseWheelListener l)
    public synchronized MouseWheelListener[] getMouseWheelListeners()

    public synchronized void addInputMethodListener(InputMethodListener l)
    public synchronized void removeInputMethodListener(InputMethodListener l)
    public synchronized InputMethodListener[] getInputMethodListeners()

    public ComponentListener.Hub onComponentEvent=....
    public FocusListener.Hub onFocusEvent=....
    public HierarchyListener.Hub onHierarchyEvent=....

........

        public interface ComponentListener extends EventListener
    {
        public void componentResized(ComponentEvent e);
        public void componentMoved(ComponentEvent e);
        public void componentShown(ComponentEvent e);
        public void componentHidden(ComponentEvent e);
        
        public class Hub
        {
            public void add(ComponentListener c){};
            public void del(ComponentListener c){};
            public ComponentListener get(){};
        }
        
    }
........

......
comp.onComponentEvent.add(componentListener);//добавление обработчика
comp.onComponentEvent.del(componentListener);//удаление обработчика
comp.onComponentEvent.get().componentShown(componentEvent);//вызов (invoke) у всех зарег. обработчиков componentShown(ComponentEvent e)
.....

Т>лично я нахожу откровенно корявым и загаживающим API. (нет? )

T> что думаете?

Избегайте опосредованных вызовов методов других классов.
Непосредственные связи довольно опасны. Опосредованные связи, такие как account.ContactPerson().DaytimeContactlnfo().PhoneNumberO, опасны еще больше. В связи с этим ученые сформулировали «Правило Деметры (Law of Demeter)» (Lieberherr and Holland, 1989), которое гласит, что Объект А может вызывать любые из собственнных методов. Если он создает Объект В, он может вызывать любые методы Объекта В, но ему не следует вызывать методы объектов, возвращаемых Объектом В. В нашем случае это означает, что вызов account.ContactPerson() приемлем, однако вызова account.ContactPerson().DaytimeContactlnfo() следовало бы избежать.

//а мине вот так писать ндравилось фсигда ;) 
new Thread()
{
    public void run()
    {
        asych_call();
    }

}.start();

myFrame.myTable.getModel().getRow().getЧтонибудьеще()

    public synchronized void addComponentListener(ComponentListener l)
    public synchronized void removeComponentListener(ComponentListener l)
    public synchronized ComponentListener[] getComponentListeners()

    public ComponentListener.Hub onComponentEvent=....

AB>myFrame.myTable.getModel().getRow().getЧтонибудьеще()
AB>

Т>    public synchronized void addComponentListener(ComponentListener l)
Т>    public synchronized void removeComponentListener(ComponentListener l)
Т>    public synchronized ComponentListener[] getComponentListeners()
Т>

Т>    public ComponentListener.Hub onComponentEvent=....
Т>

  public interface ComponentListener extends EventListener
    {
        public void componentResized(ComponentEvent e);
        public void componentMoved(ComponentEvent e);
        public void componentShown(ComponentEvent e);
        public void componentHidden(ComponentEvent e);
        
        public class Hub
        {
            public void add(ComponentListener c){};
            public void del(ComponentListener c){};
            public ComponentListener get(){};
        }
        
    }

Т>причем тут архитектура? то о чем Вы говорите — это уже использование некоторой архитектуры.

Т>такую последовательность вызовов несможет предотвратить ни одна архитектура, ну, кроме разве той, согласно которой методу запрещено возвращать ссылку на объект. но это не идеология JAVA, вроди так

comp.onComponentEvent.add(componentListener);//добавление обработчика
comp.onComponentEvent.del(componentListener);//удаление обработчика
comp.onComponentEvent.get().componentShown(componentEvent);//вызов (invoke) у всех зарег. обработчиков

Т>Но (!) как это может быть устроено внутри? что думаете?

Т>......
Т>comp.onComponentEvent.add(componentListener);//добавление обработчика
Т>comp.onComponentEvent.del(componentListener);//удаление обработчика
Т>comp.onComponentEvent.get().componentShown(componentEvent);//вызов (invoke) у всех зарег. обработчиков componentShown(ComponentEvent e)
Т>.....
Т>

Т>Но (!) как это может быть устроено внутри? что думаете?

package muticast;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;

/**
 * @author dshe
 *
 */
public final class Multicast<T> {
    private static final Map<Class<?>, Object> DEF_VALUES_CLASS_TO_OBJECT;
    static {
        DEF_VALUES_CLASS_TO_OBJECT = new HashMap<Class<?>, Object>();
        DEF_VALUES_CLASS_TO_OBJECT.put(boolean.class, Boolean.FALSE);
        DEF_VALUES_CLASS_TO_OBJECT.put(byte.class, new Byte((byte) 0));
        DEF_VALUES_CLASS_TO_OBJECT.put(short.class, new Short((short) 0));
        DEF_VALUES_CLASS_TO_OBJECT.put(char.class, new Character('\0'));
        DEF_VALUES_CLASS_TO_OBJECT.put(int.class, new Integer(0));
        DEF_VALUES_CLASS_TO_OBJECT.put(long.class, new Long(0L));
        DEF_VALUES_CLASS_TO_OBJECT.put(float.class, new Float(0f));
        DEF_VALUES_CLASS_TO_OBJECT.put(double.class, new Double(0d));
    }

    class Handler implements InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object[] array = _list.toArray();
            Throwable thrown = null;
            for(int i = 0, n = array.length; i < n; ++i) {
                try {
                    method.invoke(array[i], args);
                }
                catch(IllegalAccessException exc) {
                    throw (Error) new IllegalAccessError().initCause(exc);
                }
                catch(InvocationTargetException exc) {
                    thrown = exc.getTargetException();
                }
            }
            // rethrow last occured exception
            if(thrown != null)
                throw thrown;
            // we cannot return null if method returns primitive value
            // thus we lookup default value is a table.
            return DEF_VALUES_CLASS_TO_OBJECT.get(method.getReturnType());
        }
    }

    private final List<T> _list;
    private final Class<T> _iface;
    private final T _proxy;

    private Multicast(Class<T> iface) {
        _list = new Vector<T>();
        _iface = iface;
        // unchecked cast: dont worry
        _proxy = (T) Proxy.newProxyInstance(iface.getClassLoader(), new Class[] { iface }, new Handler());
    }

    // static factory method is just for convenient type inference
    public static <U> Multicast<U> create(Class<U> iface) {
        return new Multicast<U>(iface);
    }

    public T fire() {
        return _proxy;
    }

    public void add(T obj) {
        if(!_iface.isInstance(obj))
            throw new IllegalArgumentException("obj : " + obj);
        _list.add(obj);
    }

    public void remove(T obj) {
        if(!_iface.isInstance(obj))
            throw new IllegalArgumentException("obj : " + obj);
        _list.remove(obj);
    }
}

        Multicast<Runnable> multicast = Multicast.create(Runnable.class);
        Runnable a = new Runnable() {
            public void run() {
                System.out.println("one");
            }
        };
        Runnable b = new Runnable() {
            public void run() {
                System.out.println("two");
            }
        };
        multicast.add(a);
        multicast.add(b);
        multicast.fire().run();
        multicast.remove(b);
        multicast.fire().run();

Т>>лично я нахожу откровенно корявым и загаживающим API. (нет? )

T>> что думаете?

comp.addComponentListener(componentListener);
comp.removeComponentListener(componentListener);
comp.fireComponentShown(componentEvent);

comp.onComponentEvent.add(componentListener);
comp.onComponentEvent.del(componentListener);
comp.onComponentEvent.get().componentShown(componentEvent);