Cómo llamar a la función con devoluciones de llamada en Java como lo hago en C#?

Question

estoy bastante nuevo en Java, pero tengo que escribir algo así como el código C# (esto es prototipo escrito a mano sólo para ilustrar lo que necesito)

private void ParentFunc() 
{ 
    var worker = new WorkerClass() 

    worker.DoWork(e => console.Write("Progress" + e)); 


} 

public class WorkerClass() 
{ 
    public method DoWork(Action<int> callback) 
    { 
     for (int i=1; i<1000; i++) callback.Invoke(i); 
    } 
} 

poca explicación. Estoy usando AsyncTask en Android y llamo a un procesador externo clasificado pero me gustaría que me devolvieran la señal para que pueda publishProgress. Yo prefiero no poner interfaz a través de mi AsyncTask

Answer 1

Desde cierres no son compatibles con todo lo que tiene que utilizar el interfaz y la clase interna anónima.

private void ParentFunc { 
    WorkerClass worker = new WorkerClass(); 

    worker.doWork(new Callback<Integer>() { 
     public void invoke(Integer arg) { 
      System.out.println("Progress" + arg); 
     } 
    }); 
} 

public class WorkerClass { 
    public doWork(Callback<Integer> callback) { 
     for (int i=1; i<1000; i++) callback.invoke(i); 
    } 
} 

public interface Callback<T> { 
    public void invoke(T arg); 
} 

Answer 2

Con la ayuda de una clase de apoyo:

interface CallBack<P> 
{ 
    public void callback(P p); 
} 

class MyCallBack implements CallBack<String> { 
    public void callBack(String p) { 
    System.out.println(p); 
    } 
} 

class WorkerClass { 
    public void doWork(CallBack<String> callback) 
    { 
    // do work 
    callback.callBack("Done!"); 
    } 
} 

WorkerClass wc = new WorkerClass(); 
wc.doWork(new MyCallBack()); 

yo no voy a sugerir que utilizar las clases anónimas porque me encuentro bastante detallado hasta una sintaxis más pulido no estará disponible, pero es solo una cuestión de gusto personal, termino perdiéndome entre llaves cuando los uso ...

Answer 3

En Java, utiliza clases anónimas que implementan interfaces. Esto es algo más detallado, pero funciona muy bien:

interface MyAction { 
    void doit(String str); 
} 

class WorkerClass { 
    void doWork(MyAction action); 
} 

void main(String args[]) { 
    WorkerClass worker = new WorkerClass(); 
    worker.doWork(new MyAction { 
     public void doit(String e) { 
      System.out.println("Progress" + e) 
     } 
    }); 
} 

Answer 4

Es posible con java 8. Véase mi respuesta a la pregunta duplicado:

https://stackoverflow.com/a/26776520/1206998

utilizar una función como argumento:

import java.util.function.Function; 

public String applyFunction(Function<String,String> function){ 
     return function.apply("what ever"); 
} 

llamada

// with someObject.someMethod(String) => String 
xxx.applyFunction(someObject::someMethod);