Come chiamare la funzione con i callback in Java come faccio in C#?

Question

Sono abbastanza nuovo a Java, ma ho bisogno di scrivere qualcosa di simile a questo codice C# (questo è il prototipo digitato a mano solo per illustrare quello che mi serve)

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); 
    } 
} 

piccola spiegazione. Sto usando AsyncTask in Android e chiamando il processore esterno in classe, ma mi piacerebbe che loro segnalino così posso publishProgress. Io preferisco non mettere l'interfaccia sopra la mia AsyncTask

Answer 1

Dal momento che le chiusure non sono ancora supportati è necessario utilizzare l'interfaccia e la classe interna anonima.

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 l'aiuto di una classe di supporto:

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()); 

io non ho intenzione di suggerire di utilizzare le classi anonime perché li trovo abbastanza prolisso fino a una sintassi lisciante non sarà disponibile ma è solo una questione di gusto personale, finisco per perdere me stesso tra parentesi quando li uso ..

Answer 3

In java, si usano classi anonime che implementano le interfacce. Questo è un po 'più prolisso, ma funziona bene:

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

E 'possibile con Java 8. Vedere la mia risposta alla domanda duplicato:

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

utilizzare una funzione come argomento:

import java.util.function.Function; 

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

chiamata

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