“在计算机编程中，回调是对可执行代码或一段可执行代码的引用，该代码作为参数传递给其他代码。这允许较低层的软件层调用较高层中定义的子例程（或函数）。” -维基百科
使用函数指针在C中进行回调
在C语言中，回调是使用功能指针实现的。函数指针-顾名思义，它是指向函数的指针。
例如，int（* ptrFunc）（）;
在这里，ptrFunc是指向不带任何参数并返回整数的函数的指针。不要忘记加括号，否则编译器会假设ptrFunc是一个普通的函数名，它不做任何事情并返回一个指向整数的指针。
这是一些代码来演示函数指针。
#include<stdio.h>
int func(int, int);
int main(void)
{
int result1,result2;
/* declaring a pointer to a function which takes
two int arguments and returns an integer as result */
int (*ptrFunc)(int,int);
/* assigning ptrFunc to func's address */
ptrFunc=func;
/* calling func() through explicit dereference */
result1 = (*ptrFunc)(10,20);
/* calling func() through implicit dereference */
result2 = ptrFunc(10,20);
printf("result1 = %d result2 = %d\n",result1,result2);
return 0;
}
int func(int x, int y)
{
return x+y;
}
现在让我们尝试使用函数指针来理解C语言中回调的概念。
完整的程序包含三个文件：callback.c，reg_callback.h和reg_callback.c。
/* callback.c */
#include<stdio.h>
#include"reg_callback.h"
/* callback function definition goes here */
void my_callback(void)
{
printf("inside my_callback\n");
}
int main(void)
{
/* initialize function pointer to
my_callback */
callback ptr_my_callback=my_callback;
printf("This is a program demonstrating function callback\n");
/* register our callback function */
register_callback(ptr_my_callback);
printf("back inside main program\n");
return 0;
}
/* reg_callback.h */
typedef void (*callback)(void);
void register_callback(callback ptr_reg_callback);
/* reg_callback.c */
#include<stdio.h>
#include"reg_callback.h"
/* registration goes here */
void register_callback(callback ptr_reg_callback)
{
printf("inside register_callback\n");
/* calling our callback function my_callback */
(*ptr_reg_callback)();
}
如果我们运行该程序，输出将是
这是一个程序，该程序在主程序内部的register_callback内部的my_callback内部演示函数回调
较高层的函数将较低层的函数作为普通调用来调用，并且回调机制允许较低层的函数通过指向回调函数的指针来调用较高层的函数。
Java使用界面中的回调
Java没有函数指针的概念。它通过其接口机制实现回调机制。在此，我们声明一个接口，该接口具有一个函数，该方法将在被调用者完成其任务时被调用，而不是函数指针。
让我通过一个示例进行演示：
回调接口
public interface Callback
{
public void notify(Result result);
}
呼叫者或更高级别的班级
public Class Caller implements Callback
{
Callee ce = new Callee(this); //pass self to the callee
//Other functionality
//Call the Asynctask
ce.doAsynctask();
public void notify(Result result){
//Got the result after the callee has finished the task
//Can do whatever i want with the result
}
}
被调用者或下层功能
public Class Callee {
Callback cb;
Callee(Callback cb){
this.cb = cb;
}
doAsynctask(){
//do the long running task
//get the result
cb.notify(result);//after the task is completed, notify the caller
}
}
使用EventListener模式进行回调
此模式用于通知0到n个观察者/侦听器特定任务已完成
回调机制和EventListener / Observer机制之间的区别在于，在回调中，被叫方通知单个调用方，而在Eventlisener / Observer中，被叫方可以通知对该事件感兴趣的任何人（该通知可能会转到该事件的其他部分。尚未触发任务的应用程序）
让我通过一个例子来解释。
事件界面
public interface Events {
public void clickEvent();
public void longClickEvent();
}
类小部件
package com.som_itsolutions.training.java.exampleeventlistener;
import java.util.ArrayList;
import java.util.Iterator;
public class Widget implements Events{
ArrayList<OnClickEventListener> mClickEventListener = new ArrayList<OnClickEventListener>();
ArrayList<OnLongClickEventListener> mLongClickEventListener = new ArrayList<OnLongClickEventListener>();
@Override
public void clickEvent() {
// TODO Auto-generated method stub
Iterator<OnClickEventListener> it = mClickEventListener.iterator();
while(it.hasNext()){
OnClickEventListener li = it.next();
li.onClick(this);
}
}
@Override
public void longClickEvent() {
// TODO Auto-generated method stub
Iterator<OnLongClickEventListener> it = mLongClickEventListener.iterator();
while(it.hasNext()){
OnLongClickEventListener li = it.next();
li.onLongClick(this);
}
}
public interface OnClickEventListener
{
public void onClick (Widget source);
}
public interface OnLongClickEventListener
{
public void onLongClick (Widget source);
}
public void setOnClickEventListner(OnClickEventListener li){
mClickEventListener.add(li);
}
public void setOnLongClickEventListner(OnLongClickEventListener li){
mLongClickEventListener.add(li);
}
}
类按钮
public class Button extends Widget{
private String mButtonText;
public Button (){
}
public String getButtonText() {
return mButtonText;
}
public void setButtonText(String buttonText) {
this.mButtonText = buttonText;
}
}
类复选框
public class CheckBox extends Widget{
private boolean checked;
public CheckBox() {
checked = false;
}
public boolean isChecked(){
return (checked == true);
}
public void setCheck(boolean checked){
this.checked = checked;
}
}
活动课
包com.som_itsolutions.training.java.exampleeventlistener;
public class Activity implements Widget.OnClickEventListener
{
public Button mButton;
public CheckBox mCheckBox;
private static Activity mActivityHandler;
public static Activity getActivityHandle(){
return mActivityHandler;
}
public Activity ()
{
mActivityHandler = this;
mButton = new Button();
mButton.setOnClickEventListner(this);
mCheckBox = new CheckBox();
mCheckBox.setOnClickEventListner(this);
}
public void onClick (Widget source)
{
if(source == mButton){
mButton.setButtonText("Thank you for clicking me...");
System.out.println(((Button) mButton).getButtonText());
}
if(source == mCheckBox){
if(mCheckBox.isChecked()==false){
mCheckBox.setCheck(true);
System.out.println("The checkbox is checked...");
}
else{
mCheckBox.setCheck(false);
System.out.println("The checkbox is not checked...");
}
}
}
public void doSomeWork(Widget source){
source.clickEvent();
}
}
其他类
public class OtherClass implements Widget.OnClickEventListener{
Button mButton;
public OtherClass(){
mButton = Activity.getActivityHandle().mButton;
mButton.setOnClickEventListner(this);//interested in the click event //of the button
}
@Override
public void onClick(Widget source) {
if(source == mButton){
System.out.println("Other Class has also received the event notification...");
}
}
主班
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Activity a = new Activity();
OtherClass o = new OtherClass();
a.doSomeWork(a.mButton);
a.doSomeWork(a.mCheckBox);
}
}
从上面的代码中可以看到，我们有一个称为事件的接口，该接口基本上列出了应用程序可能发生的所有事件。Widget类是所有UI组件（如Button，Checkbox）的基类。这些UI组件是实际从框架代码接收事件的对象。窗口小部件类实现事件接口，并且它具有两个嵌套接口，即OnClickEventListener和OnLongClickEventListener
这两个接口负责侦听在Widget派生的UI组件（例如Button或Checkbox）上可能发生的事件。因此，如果将本示例与使用Java接口的早期Callback示例进行比较，则这两个接口将用作Callback接口。因此，较高级别的代码（此处的活动）实现了这两个接口。而且，每当窗口小部件发生事件时，就会调用更高级别的代码（或在更高级别的代码中实现的这些接口的方法，在这里为Activity）。
现在让我讨论Callback和Eventlistener模式之间的基本区别。正如我们已经提到的，使用回叫，被叫方只能通知一个呼叫者。但是，对于EventListener模式，应用程序的任何其他部分或类都可以注册按钮或复选框上可能发生的事件。此类的示例是OtherClass。如果您看到OtherClass的代码，则会发现它已将自己注册为ClickEvent的侦听器，该事件可能在Activity中定义的Button中发生。有趣的是，除了活动（调用方）之外，只要在Button上发生click事件，此OtherClass也将得到通知。
