我发现使用反射库实现的想法很有趣，并提出了这个，我认为它工作得很好。唯一的缺点是丢失了传递有效参数的编译时检查。

public class CallBack {
    private String methodName;
    private Object scope;

    public CallBack(Object scope, String methodName) {
        this.methodName = methodName;
        this.scope = scope;
    }

    public Object invoke(Object... parameters) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        Method method = scope.getClass().getMethod(methodName, getParameterClasses(parameters));
        return method.invoke(scope, parameters);
    }

    private Class[] getParameterClasses(Object... parameters) {
        Class[] classes = new Class[parameters.length];
        for (int i=0; i < classes.length; i++) {
            classes[i] = parameters[i].getClass();
        }
        return classes;
    }
}

你可以这样使用它

public class CallBackTest {
    @Test
    public void testCallBack() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        TestClass testClass = new TestClass();
        CallBack callBack = new CallBack(testClass, "hello");
        callBack.invoke();
        callBack.invoke("Fred");
    }

    public class TestClass {
        public void hello() {
            System.out.println("Hello World");
        }

        public void hello(String name) {
            System.out.println("Hello " + name);
        }
    }
}

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

一针见血::

首先要做一个简单的接口

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

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

如果你指的是。net匿名委托，我认为Java的匿名类也可以使用。

public class Main {

    public interface Visitor{
        int doJob(int a, int b);
    }


    public static void main(String[] args) {
        Visitor adder = new Visitor(){
            public int doJob(int a, int b) {
                return a + b;
            }
        };

        Visitor multiplier = new Visitor(){
            public int doJob(int a, int b) {
                return a*b;
            }
        };

        System.out.println(adder.doJob(10, 20));
        System.out.println(multiplier.doJob(10, 20));

    }
}

在Java 8中，这个任务很简单，如果你想在多线程场景中使用回调，你可以像下面这样做:

public  void methodA (int n, IntConsumer consumer) {
    
    // create a thread
    Thread t = new Thread(() -> {
        // some time consuming operation
        int result = IntStream.range(0, n).sum();
        // after the result is ready do something with it.
        consumer.accept(result);
    });
    t.start();
}

使用这个方法:

methodA(1000000, System.out::println);

方法在Java中还不是一级对象;不能将函数指针作为回调函数传递。相反，创建一个对象(通常实现一个接口)，其中包含您需要的方法并传递该方法。

对于Java中的闭包(它将提供您正在寻找的行为)已经提出了建议，但在即将发布的Java 7中不会包含任何建议。

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

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

用法:

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

或者使用Java8 lambdas

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