Why do I need the EventBus library or its Otto counterpart?

If you ignore all the tricky terms, like event-oriented programming, then this library is used to organize communications (exchange of data and events) between unrelated parts of the application.
That is, this library allows you to send arbitrary data from one part of the application (for example, activity) to another (for example, a fragment) in the simplest way.
The work is based on registering the receiver of the event and then sending some events "on the air". The desired receiver will receive its signal and you can accept the sent data. Example:

First, a model class is created with initialization constructors, which will store the transmitted data:

public class MessageEvent {
    public final String message;

    public MessageEvent(String message) {
        this.message = message;
    }
}

Here is a model class MessageEvent with a single data field of type String and a constructor for initializing this data. You can create an arbitrary number of data fields of arbitrary objects, and initialization constructors can include multiple arguments.

Then in the classroom (for example, an activity) from which you need to pass our data, an event is created:

EventBus.getDefault().post(new MessageEvent("Hello everyone!"));

In the class where we want to send our data (for example, a fragment) we register the event receiver:

    @Override
    public void onStart() {
        super.onStart();
        // регистрация приемника при старте фрагмента
        EventBus.getDefault().register(this);
    }

    @Override
    public void onStop() {
        // отписываемся от регистрации при закрытии фрагмента
        EventBus.getDefault().unregister(this);
        super.onStop();
    }

    // В этом методе-колбэке мы получаем наши данные 
    // (объект `event` типа класса-модели MessageEvent)
    public void onEvent(MessageEvent event){
        // извлекаем из модели отправленную строку: event.message = "Hello everyone!"
        Toast.makeText(getActivity(), event.message, Toast.LENGTH_SHORT).show();
    }

As soon as the event sending code is executed in the activity, the sent data will appear in the callback onEvent() of the fragment. Only those receivers that have the same signature in the callback as the sent event will receive this data.
In addition to model classes, you can also pass simple classes. data types, for example:

Sending:

 int num = 5;
 EventBus.getDefault().post(num);

Receiving (receiver registration omitted):

 public void onEvent(int event){
            Toast.makeText(getActivity(), "Получено число:" + event, Toast.LENGTH_SHORT).show();
    }

In general, it does not matter what you send over the bus: classes-models of a complex structure, objects, collections, arrays , or primitive types - all this will be delivered to the recipient in one piece.

From the data exchange tools that the Android system itself implements, this solution is favorably distinguished by the simplicity and transparency of use, the absence of any connection between sender and receiver, and the ability to transmit data of any type and in any quantity without any partitioning or serialization.

The library also allows you to send "sticky" events (they will not disappear until other data is sent, for example, when transmitting between two activiti, when the receiver does not exist at the time of transmitting the event, the data will be received when the receiver appears), work with asynchronous threads, and so on. See the documentation for details.

There are also other libraries with similar functionality, such as Square Otto.
In addition, the concept of reactive programming has gone much further - the framework RxJava and the add-ons for Android-the framework RxAndroid, which takes into account the specifics of the platform.