“ ในการเขียนโปรแกรมคอมพิวเตอร์การเรียกกลับเป็นการอ้างอิงถึงรหัสที่ใช้งานได้หรือส่วนหนึ่งของรหัสที่สามารถเรียกทำงานได้ซึ่งจะถูกส่งเป็นอาร์กิวเมนต์ไปยังรหัสอื่น สิ่งนี้อนุญาตให้เลเยอร์ซอฟต์แวร์ระดับต่ำกว่าเรียกรูทีนย่อย (หรือฟังก์ชัน) ที่กำหนดในเลเยอร์ระดับสูงกว่า” - วิกิพีเดีย
โทรกลับใน C โดยใช้ฟังก์ชั่นตัวชี้
ใน C การเรียกกลับถูกนำไปใช้โดยใช้ Function Pointer ตัวชี้ฟังก์ชั่น - ตามชื่อแนะนำเป็นตัวชี้ไปยังฟังก์ชั่น
ตัวอย่างเช่น 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 ไม่ได้มีแนวคิดของตัวชี้ฟังก์ชั่นมันใช้กลไกการโทรกลับผ่านกลไกอินเตอร์เฟซที่นี่แทนที่จะเป็นตัวชี้ฟังก์ชั่นเราประกาศอินเตอร์เฟซที่มีวิธีการซึ่งจะถูกเรียกเมื่อ callee เสร็จสิ้นภารกิจของมัน
ให้ฉันสาธิตผ่านตัวอย่าง:
อินเตอร์เฟสการติดต่อกลับ
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
}
}
ฟังก์ชัน Callee หรือฟังก์ชันเลเยอร์ที่ต่ำกว่า
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 คือในการติดต่อกลับผู้แจ้งเตือนจะแจ้งผู้โทรเพียงคนเดียวในขณะที่ผู้จัดกิจกรรมผู้สังเกตการณ์ / ผู้สังเกตการณ์สามารถแจ้งผู้ที่สนใจเหตุการณ์นั้นได้ (การแจ้งเตือนอาจไปยังส่วนอื่น ๆ ของ แอปพลิเคชั่นที่ไม่ได้ทริกเกอร์งาน)
ให้ฉันอธิบายผ่านตัวอย่าง
อินเทอร์เฟซเหตุการณ์
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 ทั้งหมดเช่นปุ่ม, ช่องทำเครื่องหมาย ส่วนประกอบ UI เหล่านี้เป็นวัตถุที่รับเหตุการณ์จากรหัสเฟรมเวิร์ก คลาสวิดเจ็ตใช้อินเทอร์เฟซเหตุการณ์และมีอินเทอร์เฟซซ้อนกันสองรายการ ได้แก่ OnClickEventListener & OnLongClickEventListener
อินเทอร์เฟซสองเหล่านี้มีหน้าที่รับผิดชอบในการรับฟังเหตุการณ์ที่อาจเกิดขึ้นกับส่วนประกอบ UI ที่ได้รับจาก Widget เช่นปุ่มหรือช่องทำเครื่องหมาย ดังนั้นหากเราเปรียบเทียบตัวอย่างนี้กับตัวอย่างการติดต่อกลับก่อนหน้านี้โดยใช้ Java Interface ทั้งสองอินเตอร์เฟสนี้จะทำงานเป็นอินเตอร์เฟสการติดต่อกลับ ดังนั้นรหัสระดับที่สูงขึ้น (กิจกรรมที่นี่) จะใช้อินเทอร์เฟซทั้งสองนี้ และเมื่อใดก็ตามที่มีเหตุการณ์เกิดขึ้นกับวิดเจ็ตรหัสระดับที่สูงขึ้น (หรือวิธีการของอินเทอร์เฟซเหล่านี้ถูกนำไปใช้ในรหัสระดับที่สูงกว่าซึ่งเป็นที่นี่กิจกรรม) จะถูกเรียก
ตอนนี้ให้ฉันพูดถึงความแตกต่างพื้นฐานระหว่างรูปแบบการโทรกลับและ Eventlistener ดังที่เราได้กล่าวไปแล้วว่าการใช้การโทรกลับผู้ใช้สามารถแจ้งเตือนได้เพียงผู้โทรเดียว แต่ในกรณีของรูปแบบ EventListener ส่วนอื่น ๆ หรือคลาสของแอปพลิเคชันสามารถลงทะเบียนสำหรับเหตุการณ์ที่อาจเกิดขึ้นในปุ่มหรือช่องทำเครื่องหมาย ตัวอย่างของคลาสประเภทนี้คือ OtherClass หากคุณเห็นรหัสของ OtherClass คุณจะพบว่ามันได้ลงทะเบียนตัวเองเป็นผู้ฟังของ ClickEvent ที่อาจเกิดขึ้นในปุ่มที่กำหนดไว้ในกิจกรรม ส่วนที่น่าสนใจคือนอกเหนือจากกิจกรรม (ตัวเรียก), OtherClass นี้จะได้รับการแจ้งเตือนเมื่อใดก็ตามที่มีเหตุการณ์การคลิกเกิดขึ้นบนปุ่ม
