很多时候，总是听说接口回调，回调函数，总是看到形如CallBack()的方法。那什么是回调？回调的实质又是什么？

回就是返回，就是回去，调就是调用，回调就是跑回去调用之前的东西。并没有什么神秘，也不是什么高深的东西。它在本质上也是调用

既然是跑回去调用之前的东西，怎么体现？

typescript：

export class Test{
    go(): void{
        let nima = new Nima();  
        nima.wocao();
    }
}

我们调用一个方法是类似于这样的，nima.wocao()，在Test 体中，nima对象返回自己家调用了自己本身的方法。这算不算是一种“回调”？

我个人觉得是。但通常情况下，我们看到的回调是这样子的：

TypeScript：

export class Test{
    private lists: Array<string> = new Array<string>();
    go( finish: Function ){
        for(let i = 0; i<100;i++){
            this.lists[i] = i+"";
            if(i==99){
                finish();
            }
        }
    }
}

let test = new Test();
test.go(function(){
    alert("执行结束");
});

这是把函数当作参数传递到go（）方法中，并在最后一次循环时执行。于是，在代码上就表现成了这样。

这就是回调了，可这和下面的代码有本质上的区别吗？

typeScript:

export class Test{
    private lists: Array<string> = new Array<string>();
    go( wocao: Wocao ){
        for(let i = 0; i<100;i++){
            this.lists[i] = i+"";
            if(i==99){
                wocao.finish();
            }
        }
    }
}
export class Wocao{
    finish(){
        alert("执行结束");
    }
}

let test = new Test();
test.go(new Wocao());

这里，只是不直接将函数当作参数传递过去，而是把一个对象传递过去，然后再执行对象中的函数。

当Wocao不是类，而是接口时，又是什么样的？

TypeScript:

export class Test{
    private lists: Array<string> = new Array<string>();
    go( wocao: Wocao ){
        for(let i = 0; i<100;i++){
            this.lists[i] = i+"";
            if(i==99){
                wocao.finish();
            }
        }
    }
}
interface Wocao{
    finish();
}

export class WocaoLe implements Wocao{
    finish(){
        alert("执行结束");
    }
}

let test = new Test();
test.go(new WocaoLe());

咦，很像一个监听方法是吧。是的，其实表现出来就是起到了监听的作用。

还觉得不像，换成java党

package date0716;

import java.util.ArrayList;

public class Nima {

    public static class Test{
        private ArrayList<String> lists = new ArrayList<>();

        public void go(WocaoListener wocao){
            for(int i = 0;i<100;i++){
                lists.add(i+"");
                if(i==99){
                wocao.finish();
                }
            }
        }
    }

    interface WocaoListener{
        void finish();
    }

    public static void main(String[] args) {

        Test test = new Test();
       test.go(new WocaoListener() {

        @Override
        public void finish() {
            System.out.println("执行结束");

        }
    });

    }

}

所谓的回调，其实就是这样。

——end