Вместо того, чтобы каждый Listener имел определенные методы для каждого типа события, которое вы можете отправить, измените интерфейс, чтобы он принимал общий Event класс. Затем вы можете подклассифицировать Event к определенным подтипам, если вам нужно, или сделать так, чтобы он содержал состояние, такое как double intensity.

TigerListener и ElephentListener затем становятся

interface TigerListener {
    void listen(Event event);
}

Фактически, вы можете затем преобразовать этот интерфейс в простой Listener:

interface Listener {
    void listen(Event event);
}

Ваши Listener реализации могут затем содержать логику, которая им нужна для конкретных событий, которые их волнуют.

class TigerListener implements Listener {
    @Overrides
    void listen(Event event) {
        if (event instanceof GrowlEvent) {
            //handle growl...
        }
        else if (event instance of MeowEvent) {
            //handle meow
        }
        //we don't care about any other types of Events
    }
}

class ElephentListener {
    @Overrides
    void listen(Event event) {
        if (event instanceof StompEvent) {
            StompEvent stomp = (StompEvent) event;
            if ("north".equals(stomp.getLocation()) && stomp.getDistance() > 10) { 
                ... 
            }
        }
    }
}

Ключевое отношение между подписчиком и издателем заключается в том, что издатель может отправлять события подписчикам, не обязательно, что он может отправлять ему определенные типы событий - этот тип рефакторинга подталкивает эту логику из интерфейса вниз к конкретным реализациям. .

Это более общий ответ для людей, которые приходят сюда просто для того, чтобы стать слушателем. Я резюмирую Создание настраиваемых прослушивателей из CodePath. Прочтите эту статью, если вам нужно больше объяснений.

Вот шаги.

1. Определите интерфейс

Это дочерний класс, которому нужно общаться с неизвестным родителем.

public class MyClass {

    // interface
    public interface MyClassListener {
        // add whatever methods you need here
        public void onSomeEvent(String title);
    }
}

2. Создайте установщик прослушивателя.

Добавьте частную переменную-член слушателя и открытый метод установки в дочерний класс.

public class MyClass {

    // add a private listener variable
    private MyClassListener mListener = null;

    // provide a way for another class to set the listener
    public void setMyClassListener(MyClassListener listener) {
        this.mListener = listener;
    }


    // interface from Step 1
    public interface MyClassListener {
        public void onSomeEvent(String title);
    }
}

3. События прослушивателя триггера

Дочерний объект теперь может вызывать методы в интерфейсе слушателя. Обязательно проверьте значение null, потому что никто не может его слушать. (То есть родительский класс мог не вызвать метод установки для нашего слушателя.)

public class MyClass {

    public void someMethod() {
        // ...

        // use the listener in your code to fire some event
        if (mListener != null) 
            mListener.onSomeEvent("hello");
    }


    // items from Steps 1 and 2

    private MyClassListener mListener = null;

    public void setMyClassListener(MyClassListener listener) {
        this.mListener = listener;
    }

    public interface MyClassListener {
        public void onSomeEvent(String myString);
    }
}

4. Реализуйте обратные вызовы слушателя в родительском элементе.

Теперь родительский элемент может использовать прослушиватель, который мы настроили в дочернем классе.

Пример 1

public class MyParentClass {

    private void someMethod() {

        MyClass object = new MyClass();
        object.setMyClassListener(new MyClass.MyClassListener() {
            @Override
            public void onSomeEvent(String myString) {
                // handle event
            }
        });
    }
}

Пример 2

public class MyParentClass implements MyClass.MyClassListener {

    public MyParentClass() {
        MyClass object = new MyClass();
        object.setMyClassListener(this);
    }

    @Override
    public void onSomeEvent(String myString) {
        // handle event
    }
}

Я думаю, вы делаете это правильно, так как ваши интерфейсы имеют семантическую ценность и выражают то, что они слушают (например, рычание и мяуканье вместо топания). При общем подходе вы можете повторно использовать широковещательный код, но можете потерять удобочитаемость.

Например, есть java.beans.PropertyChangeSupport, служебная программа для реализации Оберсервера, отслеживающего изменения значений. Он выполняет широковещательную передачу, но вам все равно необходимо реализовать метод в своем доменном классе и передать его объекту PropertyChangeSupport. Методы обратного вызова сами по себе бессмысленны, а транслируемые события основаны на String:

public interface PropertyChangeListener extends java.util.EventListener {
     void propertyChange(PropertyChangeEvent evt);
}

Другой - java.util.Observable, который обеспечивает механизм трансляции, но это тоже не самое лучшее, имхо.

Мне нравится ElephantListener.onStomp()

Другой вариант - шаблон доски. Это разъединяет издателя и подписчика друг от друга, и ни один из них не будет содержать никакого широковещательного кода. Они оба просто используют механизм обмена сообщениями для публикации / подписки, и ни один из них не имеет прямой связи друг с другом.

Это обычная модель обмена сообщениями на платформе OSGi.

Я создал библиотеку сигналов только для этой цели. Для удаления кода котла, задействованного в повторной реализации механизма вещания.

Сигнал - это объект, автоматически созданный из интерфейса. У него есть методы для добавления слушателей и отправки / трансляции событий.

Выглядит это так:

interface Chat{
    void onNewMessage(String s);    
}

class Foo{
    Signal<Chat> chatSignal = Signals.signal(Chat.class);
    
    void bar(){
        chatSignal.addListener( s-> Log.d("chat", s) ); // logs all the messaged to Logcat
    }
}

class Foo2{
    Signal<Chat> chatSignal = Signals.signal(Chat.class);
    
    void bar2(){
        chatSignal.dispatcher.onNewMessage("Hello from Foo2"); // dispatches "Hello from Foo2" message to all the listeners
    }
}

В этом примере Foo2 транслирует новые сообщения через Chat интерфейс. Foo затем послушайте их и зарегистрируйте в logcat.

• Обратите внимание, что нет никаких ограничений на то, какие интерфейсы вы можете использовать.
• У вас также есть сахарный API для регистрации только для первой трансляции и отмены регистрации для всех сигналов сразу (через SignalsHelper)

Попробуйте библиотеку java kiss, и вы сделаете это быстрее и точнее.

import static kiss.API.*;

class Elephant {
  void onReceiveStomp(Stomp stomp) { ... }
}

class Tiger {
  void onReceiveMeow(Meow meow) { ... }
  void onReceiveGrowl(Growl growl) { ... }
}

class TigerMeowGenerator extends Generator<Meow> {
   // to add listeners, you get: 
   //    addListener(Object tiger); // anything with onReceiveMeow(Meow m);
   //    addListener(meow->actions()); // any lambda
   // to send meow's to all listeners, use 
   //    send(meow)
}

Генератор является поточно-ориентированным и эффективным (самое сложное - написание правильных генераторов). Это реализация идей из Java Dev. Журнал "Умение слушать на языке Java" (локальная копия)