在C語言中，函數名可以當做函數指針傳遞給形參從而實現回調

void f1() { printf("f1()\n"); }
void f2() { printf("f2()\n"); }
void f3() { printf("f3()\n"); }

void do_func(void(*f)()) { f(); }

int main()
{
    do_func(f1);
    do_func(f2);
    do_func(f3);
}

在C++11中，實現回調還可以通過函數模板和lambda表達式的方式

template <typename Func>
void
 
 do_func(Func f) { f(); }

int main()
{
    do_func([]() { printf("f1()"); });
    do_func([]() { printf("f2()"); });
    do_func([]() { printf("f3()"); });
}

而假如回調函數的代碼實現較為復雜，且具有重用價值，lambda表達式這種一次性的方案就不太適合，在C++11之前，是通過函數對象來實現的。函數對象說白了就是一個類的普通對象，只不過C++可以重載括號運算符，導致調用類的對象的operator()方法時，就像調用函數一樣自然。

而分析本質，其實回調函數就是一種函數簽名（若幹個輸入參數、一個輸出參數）的規範，java雖不存在函數聲明，但是java可以用接口來強制規範。

interface Funcable {
    void Func();
}

這樣只要實現了該接口的類，都有一個函數簽名和void Func()一致的成員函數（嘛，還是不習慣方法（method）這種叫法），於是只需要把實現了該接口的類的對象傳入函數中，然後在函數中調用該對象的Func()方法即可

class F1 implements Funcable {

    @Override
    public void Func() {
        System.out.println("f1()");
    }
    
}

public class Test {
    
    
 
public static void do_func(Funcable funcable) {
        funcable.Func();
    }
    
    public static void main(String[] args) {
        do_func(new F1());
    }
}

這裏節省代碼量，就不把類F2、F3給寫出來了。並且利用java的匿名類可以節省代碼，類似於lambda表達式

        do_func(new Funcable() {            
            @Override
            public void Func() {
                System.out.println("f2()");
            }
        });

說到lambda表達式，它是可以捕獲外部變量的，在Java這種方式還可以通過匿名內的匿名構造函數來顯式捕獲外部的變量

        String msg = "f3()";
        do_func(new Funcable() {
            String _msg;
            
            {
                _msg = msg;
            }
            
            @Override
            public void Func() {
                System.out.println(_msg);
            }
        });

這種做法就很像lambda表達式了，因為匿名類的匿名構造函數是只能以外部變量為構造參數的，相當於lambda表達式的“捕獲”，對應C++的lambda表達式寫法就是

    std::string msg = "f3()";
    do_func([&msg]() { std::cout << msg << std::endl; });

java8也有lambda表達式了，因此可以寫成這樣

do_func(() -> { System.out.println(msg); });

Java通過匿名類來實現回調函數