Java callback functions in a detailed

To understand what a callback function is, check the following information online:

Information One:

First of all, what is called a callback function?

In Windows, the programmer wants the system DLL to call a method written by itself, and then uses the interface of the callback function (CALLBACK) in the DLL to write the program, which is called the callback. When you invoke an interface, you need to strictly follow the defined parameters and method calls, and you need to handle the async of the function, which will cause the program to crash.

This explanation seems to be quite difficult to understand, here is a simple example:

Programmer a wrote a program (program a), which reserved a callback function interface, and encapsulated the program. Programmer B wants A to invoke a method in its own program B, so he callbacks his method in B through the interface in a. Objective to achieve.

In C + +, to use a callback function, the dropped function needs to tell the caller their own pointer address, but there is no pointer in Java, what to do? We can implement the definition callback function through the interface (interface).

Let's say I'm programmer a, and here's my program A:

[Java]View Plaincopyprint?

2. Public class Caller {
6. Public Mycallinterface MC;
10. Public void Setcallfuc (Mycallinterface MC) {
14. this.mc= MC;
18. }
22. Public Void Call () {
26. This.mc.method ();
30. }
34. }

I also need to define an interface so that programmer B implements the interface based on my definition of programming.

[Java]View Plaincopyprint?

1. Public interface Mycallinterface {
3. Public void Method ();
5. }

So, programmer B only needs to implement this interface to achieve the purpose of the callback:

[Java]View Plaincopyprint?

2. Public class B implements Mycallinterface {
6. Public Void Method () {
10. System.out.println ("Who will call me ah.") So lonely!!   ");
14. }
20. Public static void Main (String args[]) {
24. Caller call = new Caller ();
28. CALL.SETCALLFUC (new B ());
32. Call.call ();
36. }
40. }

public class B implements Mycallinterface {public void method () {System.out.println ("Who will call me ah.") So lonely!! "); } public static void Main (String args[]) {Caller call = new Caller (); Call.setcallfuc (new B ()); Call.call ();}}

Data two:

The so-called callback, is the client program C calls the service program s in a method A, and then s at some point in turn to call a C method B, for C, the B is called a callback function.

Generally speaking, C does not call B,c itself to provide B's purpose is to let s to invoke it, and C has to provide. Since S does not know what B is called by C, so S will contract B's interface specification (function prototype), and then by C advance through S a function R tells S itself will use B function, this process is called callback function registration, R is called the registration function.

Here's a popular example:

One day, I call to ask you questions, of course, is a problem,:), you can not think of a solution, I can't hold the phone in there silly, so we agreed: Wait until you come up with a way to call me, so I hung off the phone to do other things. After xx minutes, my cell phone rang, you cheerfully said that the problem has been taken care of, should be treated as such. The story ends here.

This example illustrates the programming pattern of asynchronous + callback. Which, you later on the phone to tell me the result is a "callback" process; my mobile phone number must be told you before, this is the registration callback function, my mobile phone number should be valid and the phone can receive your call, this is the callback function must conform to the interface specification.

If you're not sure how to look at this section of the description code:

Declare an interface, another class has a method that has a parameter to be the interface type, and then implement this interface in another class (in Java is used in the anonymous inner class), and the object generated by the anonymous class for the parameter to the above mentioned class, and then implement the callback .... This usage can be referred to in Java common to the database operations used by several interfaces .....

[Java]View Plaincopyprint?

2. Declaring an interface
6. Public interface Icallback {
10. void Postexec ();
14. }
20. Another class has a method that has a parameter in it that is the interface type
24. Public class FooBar {
28. Private Icallback CallBack;
32. Public void Setcallback (Icallback callBack) {
36. This.callback = CallBack;
40. }
44. Public void Dosth () {
48. Callback.postexec ();
52. }
56. }
60. ----------------------------------------
64. Implementation of callbacks
68. Public class Test {
72. Public static void Main (string[] args) {
76. FooBar foo = new FooBar ();
80. Foo.setcallback (new Icallback () {
84. Public void Postexec () {
88. System.out.println ("method executed.");
92. }
96. });
100. Foo.dosth (); //Call function
104. }
108. }

Declares an interface public interface Icallback {void Postexec ();} Another class has a method that has a parameter in it that is the public class of this interface type FooBar {private icallback callback;public void Setcallback (Icallback callBack) { This.callback = CallBack;} public void Dosth () {callback.postexec ();}} Implementation of the----------------------------------------callback public class Test {public static void main (string[] args) {FooBar foo = new F Oobar (); Foo.setcallback (new Icallback () {public void postexec () {System.out.println ("method executed.");}); Foo.dosth ();//Call Function}}

--------------------------------------------------------------------------------------------------------------- ---------------------------------------------

Data three: A classic example of using a callback function

The following is a tool class that uses the Java callback function to implement a test function run time:

If we were to test the execution time of a method of a class, we would typically do this:

Java code

[Java]View Plaincopyprint?

2. Public class Testobject {
4. /**
6. * A method to be tested for a more time-consuming cycle
8. */
10. Public static void TestMethod () {
12. for ( int i= 0; i< 100000000; i++) {
16. }
18. }
20. /**
22. * A simple way to test the execution time of a method
24. */
26. Public void Testtime () {
28. Long begin = System.currenttimemillis (); //Test start time
30. TestMethod (); //test method
32. Long end = System.currenttimemillis (); //test End time
34. System.out.println ("[Use time]:" + (End-begin)); //Print usage time
36. }
40. Public static void Main (string[] args) {
42. Testobject test=New Testobject ();
44. Test.testtime ();
46. }
48. }

You see the Testtime () method, only "//test method" is needed to change, let's do a function to achieve the same function but more flexible:

First, set a callback interface:

Java code

[Java]View Plaincopyprint?

2. Public interface CallBack {
4. Methods for performing callback operations
6. void execute ();
8. }
14. Then write a tool class:
18. Java code
22. Public class Tools {
26. /**
28. * Test function usage time, by defining the Execute method of the callback interface
30. * @param callBack
32. */
34. Public void Testtime (CallBack CallBack) {
36. Long begin = System.currenttimemillis (); //Test start time
38. Callback.execute (); // for callback operation
40. Long end = System.currenttimemillis (); //test End time
42. System.out.println ("[Use time]:" + (End-begin)); //Print usage time
44. }
48. Public static void Main (string[] args) {
50. Tools tool = new tools ();
52. Tool.testtime (new CallBack () {
54. Defining the Execute Method
56. Public Void Execute () {
58. Here you can add one or more methods to test the run-time
60. Testobject.testmethod ();
62. }
64. });
66. }
70. }

As you can see, testtime () passed the Execute () method that defines the callback interface to implement the callback function

Java callback functions in a detailed