Crea un evento personalizado en Java

Quiero hacer algo así en Java pero no sé cómo:

Cuando el evento "objeto 1 dice 'hola'" ocurre, entonces el objeto 2 responde a ese evento diciendo "hola".

¿Alguien puede darme una pista o un código de muestra?

Probablemente quieras mirar en el patrón de observador .

Aquí hay un código de muestra para comenzar:

import java.util.*;

// An interface to be implemented by everyone interested in "Hello" events
interface HelloListener {
    void someoneSaidHello();
}

// Someone who says "Hello"
class Initiater {
    private List<HelloListener> listeners = new ArrayList<HelloListener>();

    public void addListener(HelloListener toAdd) {
        listeners.add(toAdd);
    }

    public void sayHello() {
        System.out.println("Hello!!");

        // Notify everybody that may be interested.
        for (HelloListener hl : listeners)
            hl.someoneSaidHello();
    }
}

// Someone interested in "Hello" events
class Responder implements HelloListener {
    @Override
    public void someoneSaidHello() {
        System.out.println("Hello there...");
    }
}

class Test {
    public static void main(String[] args) {
        Initiater initiater = new Initiater();
        Responder responder = new Responder();

        initiater.addListener(responder);

        initiater.sayHello();  // Prints "Hello!!!" and "Hello there..."
    }
}

Artículo relacionado: Java: crear un evento personalizado

Lo que quieres es una implementación del patrón de observador . Puede hacerlo usted mismo por completo, o usar clases de Java como java.util.Observeryjava.util.Observable

Hay 3 formas diferentes en que puede configurar esto:

1. Thrower dentro de Catcher
2. Catcher dentro de Thrower
3. Throwery Catcherdentro de otra clase en este ejemploTest

EL EJEMPLO DE GITHUB DE TRABAJO QUE ESTOY CITANDO Por defecto a la Opción 3, para probar los otros simplemente descomente el "Optional" bloque de código de la clase que desea que sea principal y configure esa clase como la${Main-Class}variable en elbuild.xmlarchivo:

4 cosas necesarias para lanzar el código lateral:

import java.util.*;//import of java.util.event

//Declaration of the event's interface type, OR import of the interface,
//OR declared somewhere else in the package
interface ThrowListener {
    public void Catch();
}
/*_____________________________________________________________*/class Thrower {
//list of catchers & corresponding function to add/remove them in the list
    List<ThrowListener> listeners = new ArrayList<ThrowListener>();
    public void addThrowListener(ThrowListener toAdd){ listeners.add(toAdd); }
    //Set of functions that Throw Events.
        public void Throw(){ for (ThrowListener hl : listeners) hl.Catch();
            System.out.println("Something thrown");
        }
////Optional: 2 things to send events to a class that is a member of the current class
. . . go to github link to see this code . . .
}

2 cosas necesarias en un archivo de clase para recibir eventos de una clase

/*_______________________________________________________________*/class Catcher
implements ThrowListener {//implement added to class
//Set of @Override functions that Catch Events
    @Override public void Catch() {
        System.out.println("I caught something!!");
    }
////Optional: 2 things to receive events from a class that is a member of the current class
. . . go to github link to see this code . . .
}

Lo siguiente no es exactamente lo mismo pero similar, estaba buscando un fragmento para agregar una llamada al método de interfaz, pero encontré esta pregunta, así que decidí agregar este fragmento para aquellos que lo estaban buscando como yo y encontré esta pregunta :

 public class MyClass
 {
        //... class code goes here

        public interface DataLoadFinishedListener {
            public void onDataLoadFinishedListener(int data_type);
        }

        private DataLoadFinishedListener m_lDataLoadFinished;

        public void setDataLoadFinishedListener(DataLoadFinishedListener dlf){
            this.m_lDataLoadFinished = dlf;
        }



        private void someOtherMethodOfMyClass()
        {
            m_lDataLoadFinished.onDataLoadFinishedListener(1);
        }    
    }

El uso es el siguiente:

myClassObj.setDataLoadFinishedListener(new MyClass.DataLoadFinishedListener() {
            @Override
            public void onDataLoadFinishedListener(int data_type) {
                }
            });