Saltar al contenido

Equivalente en Java de Delegados de C # (métodos de cola de varias clases que se ejecutarán)

Solución:

En realidad, no existe una contraparte exacta para los delegados en Java. Pero hay construcciones que imitan su comportamiento.

Java 8

Interfaces funcionales

El concepto que se acerca a los delegados en Java 8 es el de interfaces funcionales.

Por ejemplo, si tiene un delegado de C #:

delegate void Runnable();

en Java, crearía una interfaz funcional como:

@FunctionalInterface
public interface Runnable {
    void run();
}

Lo bueno de las interfaces funcionales es que se pueden usar fácilmente en expresiones lambda.

Ejemplo

Entonces, supongamos que tienes la siguiente clase:

public class SomeClass {
    public static void someStaticMethod() {
    }

    public void someMethod() {
    }
}

Expresiones lambda y referencias a métodos

Con Java 8, obtienes expresiones lambda.

List<Runnable> queue = new ArrayList<>();
queue.add(() -> someMethod());
queue.add(() -> someStaticMethod());

Hay una abreviatura llamada referencia de método para esto, si en realidad simplemente llama a un método:

List<Runnable> queue = new ArrayList<>();
queue.add(this::someMethod);
queue.add(SomeClass::someStaticMethod);

Java 7

Con Java 7, lo único que puede usar son clases anónimas:

List<Runnable> queue = new ArrayList<>();
queue.add(new Runnable() {
    public void run() {
        someMethod();
    }
});
queue.add(new Runnable() {
    public void run() {
        someStaticMethod();
    }
});

Espero que esto no haya sido demasiada información, para que aún puedas aprender. 😉 Sin embargo, me gusta que mi respuesta sea útil también para otras personas que buscan esta pregunta.

Extraído de https://msdn.microsoft.com/en-gb/library/aa288459(v=vs.71).aspx:

Un delegado en C # es similar a un puntero de función en C o C ++. El uso de un delegado permite al programador encapsular una referencia a un método dentro de un objeto delegado. El objeto delegado se puede pasar al código que puede llamar al método referenciado, sin tener que saber en el momento de la compilación qué método se invocará. A diferencia de los punteros de función en C o C ++, los delegados están orientados a objetos, con seguridad de tipos y seguros.

Dicho esto, Java no tiene delegados como C #. Sin embargo, desde Java 8, tenemos algún tipo de punteros de función mediante el uso de referencias de métodos e interfaces funcionales.

Como solicitó amablemente, no voy a decirle exactamente cómo implementar este código, pero debería poder encontrar una solución con esta información.

¡Haz clic para puntuar esta entrada!
(Votos: 0 Promedio: 0)



Utiliza Nuestro Buscador

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *