当我在Java中需要这种功能时，我通常使用观察者模式。它确实意味着一个额外的对象，但我认为这是一种干净的方式，而且是一种被广泛理解的模式，有助于提高代码的可读性。

创建一个接口，并在回调类中创建相同的接口属性。

interface dataFetchDelegate {
    void didFetchdata(String data);
}
//callback class
public class BackendManager{
   public dataFetchDelegate Delegate;

   public void getData() {
       //Do something, Http calls/ Any other work
       Delegate.didFetchdata("this is callbackdata");
   }

}

现在在你想要回调的类中实现上面的Created Interface。 同时传递你的类的“this”对象/引用回调。

public class Main implements dataFetchDelegate
{       
    public static void main( String[] args )
    {
        new Main().getDatafromBackend();
    }

    public void getDatafromBackend() {
        BackendManager inc = new BackendManager();
        //Pass this object as reference.in this Scenario this is Main Object            
        inc.Delegate = this;
        //make call
        inc.getData();
    }

    //This method is called after task/Code Completion
    public void didFetchdata(String callbackData) {
        // TODO Auto-generated method stub
        System.out.println(callbackData);
    }
}

public class HelloWorldAnonymousClasses {

    //this is an interface with only one method
    interface HelloWorld {
        public void printSomething(String something);
    }

    //this is a simple function called from main()
    public void sayHello() {

    //this is an object with interface reference followed by the definition of the interface itself

        new HelloWorld() {
            public void printSomething(String something) {
                System.out.println("Hello " + something);
            }
        }.printSomething("Abhi");

     //imagine this as an object which is calling the function'printSomething()"
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp =
                new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }
}
//Output is "Hello Abhi"

基本上，如果你想让一个接口的对象 不可能，因为接口不能有对象。

选择是让某个类实现接口，然后使用该类的对象调用该函数。 但是这种方法非常冗长。

或者，编写新的HelloWorld() (*oberserve这是一个接口而不是一个类)，然后接着定义接口方法本身。(*这个定义实际上是匿名类)。 然后获得对象引用，通过它可以调用方法本身。

然而，我看到了我最喜欢的方式，这就是我一直在寻找的。它基本上是从这些答案中衍生出来的，但我必须将其操作得更冗余和有效。我想每个人都在期待我的创意

一针见血::

首先要做一个简单的接口

public interface myCallback {
    void onSuccess();
    void onError(String err);
}

现在让这个回调在你想处理结果的时候运行-更可能是在异步调用之后，你想运行一些依赖于这些结果的东西

// import the Interface class here

public class App {

    public static void main(String[] args) {
        // call your method
        doSomething("list your Params", new myCallback(){
            @Override
            public void onSuccess() {
                // no errors
                System.out.println("Done");
            }

            @Override
            public void onError(String err) {
                // error happen
                System.out.println(err);
            }
        });
    }

    private void doSomething(String param, // some params..
                             myCallback callback) {
        // now call onSuccess whenever you want if results are ready
        if(results_success)
            callback.onSuccess();
        else
            callback.onError(someError);
    }

}

doSomething是需要一些时间的函数你想给它添加一个回调来通知你结果出来了，把回调接口作为参数添加到这个方法

希望我的观点是清楚的，享受吧;)

为了简单起见，你可以使用Runnable:

private void runCallback(Runnable callback)
{
    // Run callback
    callback.run();
}

用法:

runCallback(new Runnable()
{
    @Override
    public void run()
    {
        // Running callback
    }
});

或者使用Java8 lambdas

runCallback(() -> {
    // Running callback
});

检查闭包是如何在lambdaj库中实现的。它们实际上有一个非常类似于c#委托的行为:

http://code.google.com/p/lambdaj/wiki/Closures