关于回调函数的梳理

回调函数，是一个通过函数指针调用的函数。 如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。 在Java中，指针即所谓的引用。 回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

为了方便理解，我们用dota2中英雄释放技能的流程来举例子，当巫妖释放大招完之后，肯定不能等技能持续时间消耗殆尽再结束施法，因为技能持续的事件与释放者的释放后是不影响的。这样的设定使得施法者一经完成施法动作后就可以不用管法术释放后的传播路径，而去干自己的事情了。

下面我们简述几个不同的方式来体现这一过程。

Java 的反射机制允许我们获取类的信息，其中包括类的方法。我们将以 Method 类型去获取回调函数，然后传递给请求函数。

import java.lang.reflect.Method;

public class InvokeCallback {
    class Request{
        public void send(Class clazz, Method method) throws Exception {
            Thread.sleep(2000);
            System.out.println("法术自行命中敌人后，开始传播");
            method.invoke(clazz.newInstance());
            System.out.println("法术传播结束");
        }
    }


    
    static class CallBack{
        public void processResponse(){
            System.out.println("弹~弹~弹~弹~弹~弹~弹~弹~");
        }
    }

    public static void main(String[] args) throws InterruptedException, NoSuchMethodException {
        final InvokeCallback invokeCallback = new InvokeCallback();
        final Request request = invokeCallback.new Request();
        System.out.println("巫妖开始放大了~~~~~~~~~~");
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    request.send(CallBack.class, CallBack.class.getMethod("processResponse"));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        System.out.println("释放结束，开溜----------");
        Thread.sleep(1000 * 1000);
    }
}

由此可见，巫妖在释放技能结束后，法术的效果才开始自行执行的。

public class DirectCallback {
    class Request{
        public void send(InvokeCallback.CallBack callBack) throws Exception {
            // 模拟等待响应
            Thread.sleep(2000);
            System.out.println("法术自行命中敌人后，开始传播");
            callBack.processResponse();
            System.out.println("法术传播结束");
        }
    }


    public static void main(String[] args) throws InterruptedException {
        DirectCallback directCallback = new DirectCallback();
        final Request request = directCallback.new Request();
        System.out.println("巫妖（直接调用）开始放大了~~~~~~");
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    request.send(new InvokeCallback.CallBack());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        System.out.println("释放结束，开溜----------");
        Thread.sleep(10 * 1000);
    }
}

Callback 作为接口传入参数

public class InterfaceCallback {
    class Request{
        public void send(ResponseCallback responseCallback) throws Exception {
            Thread.sleep(2000);
            System.out.println("法术自行命中敌人后，开始传播");
            responseCallback.processResponse();
            System.out.println("法术传播结束");
        }
    }

    interface ResponseCallback{
        void processResponse();
    }

    public static void main(String[] args) throws InterruptedException {
        InterfaceCallback interfaceCallback = new InterfaceCallback();
        final Request request = interfaceCallback.new Request();
        System.out.println("（接口调用）巫妖开始放大了~~~~~~~~~~");
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    request.send(new ResponseCallback() {
                        @Override
                        public void processResponse() {
                            System.out.println("（接口方法重写）弹~弹~弹~弹~弹~弹~弹~弹~");
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        System.out.println("释放结束，开溜----------");
        Thread.sleep(10 * 1000);
    }
}