Правильная связь для нескольких слушателей, которым требуется доступ к данным общего состояния

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

Вы можете автоматизировать управление зависимостями, указав слушателям, от кого они зависят. Список слушателей будет упорядочен не по порядку вставки, а для обеспечения того, чтобы зависимые объекты следовали своей зависимости. Интерфейс вашего слушателя будет выглядеть примерно так:

interface Listener {
  String getId();
  Collection<String> getDependencies();
  onEvent(char e);
}

Или просто укажите ссылки, например:

interface Listener {
  Collection<Listener> getDependencies();
  onEvent(char e);
}

«Как бы мы изменили это так, чтобы Слушатель Б знал Слушателя А? Или даже не знал, просто каким-то образом связан?»

Вы не часто хотите объединять два «равных» объекта, как этот. Вы хотите, чтобы два партнера зависели от чего-то общего.

Более глубокий вопрос заключается в том, что слушатель A или слушатель B делают со всей собираемой информацией?

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

У вас может быть только один слушатель, который имеет несколько действий (A и B). Затем слушатель может предоставить соответствующие подсчеты как для A, так и для B. Он предоставляет счет «a» для A. Он предоставляет счет «a» или «b» для B.

Почему бы не иметь центральный объект, который будет отслеживать, сколько раз метод onEvent запускался для всех классов слушателей?

 public interface CountObserver {

 public void updateCount(String className);
 public int getCount(String className);
}

public class CentralObserver implements CountObserver {

 private int aCount;
 private int bCount;

 public void updateCount(String className) {

 //There's probably a better way to do this than using
 //all these if-elses, but you'll get the idea.

  if (className.equals("AclassName")) {
   aCount++;
  }
  else if (className.equals("BclassName")) {
   bCount++;
  }
 }

 public int getCount(String className) {

  if (className.equals("AclassName")) {
   return aCount;
  }
  else if (className.equals("BclassName")) {
   return bCount;
  }
}

class A implements Listener {

 CountObserver countObserver;

 public void registerObserver (CountObserver countObserver) {

  this.countObserver = countObserver;
 }

 public void onEvent(char e) {

  if (e == 'a') {

   countObserver.updateCount (this.getClass.getName);
  }
 }

}

//Same thing for B or any other class implementing Listener. Your Listener interface should, of 

//course, have a method signature for the registerObserver method which all the listener classes 

//will implement.

class Run {

 private A a;
 private B b; 
 private CountObserver centralObserver;

 public runProgram () {

  centralObserver = new CentralObserver();
  a.registerObserver(centralObserver);
  b.registerObserver(centralObserver);

 //run OnEvent method for A a couple of times, then for B

 }

 public int getAcount () {

 return centralObserver.getCount(a.getClass.getName());
 }

 public int getBcount () {

 return centralObserver.getCount(b.getClass.getName());
 }
} 
 //To get the sum of all the counts just call getAcount + getBcount. Of course, you can always  add more listeners and more getXCount methods