回调函数的理解

简化版：就是a调b,完了b又调a.
咋做呢？
先创建a,b两个对象。b中写一个a要调用的方法。a中写个main测试方法和要回调的方法。先new b，然后调用b中方法，完成了第一步。那么怎么在b中回调a呢。这就要在b中加个构造对象，然a对象传进来才能回调。这里为了更加通用，可以创建一个接口c，让a实现c，c可以作为构造对象的参数。
例：

public interface T1 {
   abstract void run();
}
public class T2{
    T1 t1;
    public T2(){
    }
    public T2(T1 t1){
        this.t1=t1;
    }
    public void exec(){
        t1.run();
    }
}
public class T3 implements T1{
    public static void main(String[] args) {
        T2 t2 = new T2(new T1() {
            @Override
            public void run() {
            }
        });
        t2.exec();
    }
    @Override
    public void run() {

    }
}

这里：T3要调用T2.exec,T2又回调T3的run().

把A理解成客户端，把B理解成服务器。
A要访问B，让B做事。但是B做的慢，于是B就先返回给A一个正在处理的状态，等处理完了再通知A处理结果，那么这个A通知B的手段就是回调了。通常为了加强适配性(因为服务器只有一个，而客户端有多个)，客户端都会实现接口C，再把C注入到服务器，那么服务器对外提供带有参数C的方法即可。

还有一种形式的回调，就是让服务方提供方法，在里面可以写自己的实现内容，再回调执行。
如线程，我们先new Thread,并在里面写run方法，最后再调用start方法启动。这里的start方法里面的实现也是一种回调。
最后是常见的内部类实现的一种回调形式。还是创建一个线程，
Thread t1=new Thread(new Runnable (){
public void run(){
//自己的要做的事
}
});

//回调执行里面的run方法
t1.start();

这里thread是别人写好的类，我们要使用，为了更灵活，thread提供了个是接口类型的参数，让我们自己去写里面的实现内容。写好后再回调执行。别人写的线程提供很多方法，可以编辑线程名字，查看线程状态，终止线程等功能，很方便。我想这也是为什么要使用回调的原因了。如果不使用，我们也可以自己写方法，一步步执行，但自己写的毕竟不如人家专业的

案例 ：

public class test5 {
    public static void main(String[] args) {
        //*********************回调1*******************8
        Server server=new Server();
        Client client=new Client();
        client.server=server;
        client.num=1;
        client.call();
        //*********************回调2*******************
        Server3 server3=new Server3();
        server3.num=1;
        int num3=3;
        server3.callFunc(num3, new ClientInter() {
            @Override
            public void back() {
                server3.num+=num3;
                System.out.println(server3.num);
            }
        });
        //回调，执行我们自己写的callFunc
        server3.call();
        System.out.println("server3的num:"+server3.num);
    }
}
interface  ClientInter{
    public void back();
}
class Client implements ClientInter{
    Server server;
    int num;
    public void call(){
        num+=5;
        //让服务器做事
        boolean flag=server.chuli(Client.this);
        System.out.println("服务器还在处理，先返回调用是否成功的状态："+flag);
    }

    @Override
    public void back() {
        System.out.println("服务器处理完了，回到客户端了");
        //还有再把num+5
        num+=5;
        System.out.println("客户端如果num是11，那么回调成功："+num);
    }
}
class Server{
    public boolean chuli(ClientInter clientInter){
        new Thread(()->{
            System.out.println("服务器开始处理！！！需要5s");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clientInter.back();
        }).start();
        return true;
    }
}

class Server3{
    int num;
    private ClientInter clientInter;
    public void callFunc(int num,ClientInter clientInter){
        this.num=num;
        this.clientInter=clientInter;
    }
    public void call(){
        clientInter.back();
    }
}

结果：

服务器还在处理，先返回调用是否成功的状态：true
服务器开始处理！！！需要5s
6
server3的num:6
服务器处理完了，回到客户端了
客户端如果num是11，那么回调成功：11