Callback using Interfaces in Java

Callback in C/C++ : The mechanism of calling a function from another function is called “callback”. Memory address of a function is represented as ‘function pointer’ in the languages like C and C++. So, the callback is achieved by passing the pointer of function1() to function2().

Callback in Java : But the concept of a callback function does not exist in Java because Java doesn’t have pointer concept. However, there are situations where one could speak of a callback object or a callback interface. Instead of passing the memory address of a function, interface is passed that refers to the location of a function.

Example



Let us take an example to understand where callbacks can be used. Suppose a programmer wants to design a tax calculator that calculates total tax of a state. Assume there are only two taxes, central and state tax. Central tax is common whereas the state tax varies from one state to another. The total tax is the sum of the two. Here separate method like stateTax() is implemented for every state and call this method from another method calculateTax() as:

static void calculateTax(address of stateTax() function)
{
    ct = 1000.0
    st = calculate state tax depending on the address
    total tax = ct+st;
}

In the preceding code, the address of stateTax() is passed to calculateTax(). The calculateTax() method will use that address to call stateTax() method of a particular state and the state tax ‘st’ is calculated.
Since the code of stateTax() method changes from one state to another state, it is better to declare it as an abstract method in an interface, as:

interface STax
{
     double stateTax();
}

The following is the implementtion of stateTax() for Punjab state:

class Punjab implements STax{
    public double stateTax(){
    return 3000.0;
     }
}

The following is the implementation of stateTax() for HP state:

class HP implements STax
{
    public double stateTax()
    {
        return 1000.0;
    }
}

Now, the calculateTax() method can be designed as:

static void calculateTax(STax t)
{
    // calculate central tax
    double ct = 2000.0;

    // calculate state tax
    double st = t.stateTax();
    double totaltax = st + ct;

    // display total tax
    System.out.println(“Total tax  =”+totaltax);
}

Here, observe the parameter ‘Tax t’ in the calculateTax() method. ‘t‘ is a reference of the ‘STax’ interface which is passed as a parameter to the method. Using this reference, the stateTax() method is called, as:

double st = t.stateTax();

Here, if ‘t’ refers to stateTax() method of class Punjab, then that method is called and its tax is calculated. Similarly, for class HP. In this way, by passing interface reference to calculateTax() method, it is possible to call stateTax() method of any state. This is called callback mechanism.

By passing the interface reference that refers to a method, it is possible to call and use that method from another method.

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate callback mechanism
// using interface is Java
  
// Create interface
import java.util.Scanner;
interface STax {
    double stateTax();
}
  
// Implementation class of Punjab state tax
class Punjab implements STax {
    public double stateTax()
    {
        return 3000.0;
    }
}
  
// Implementation class of Himachal Pardesh state tax
class HP implements STax {
    public double stateTax()
    {
        return 1000.0;
    }
}
  
class TAX {
    public static void main(String[] args) 
throws ClassNotFoundException, IllegalAccessException, InstantiationException
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the state name");
        String state = sc.next(); // name of the state
  
        // The state name is then stored in an object c
        Class c = Class.forName(state);
  
        // Create the new object of the class whose name is in  c
        // Stax interface reference is now referencing that new object
        STax ref = (STax)c.newInstance();
  
        /*Call the method to calculate total tax
        and pass interface reference - this is callback .
        Here, ref may refer to stateTax() of Punjab or HP classes
        depending on the class for which the object is created
        in the previous step
         */
  
        calculateTax(ref);
    }
    static void calculateTax(STax t)
    {
        // calculate central tax
        double ct = 2000.0;
  
        // calculate state tax
        double st = t.stateTax();
        double totaltax = st + ct;
  
        // display total tax
        System.out.println("Total tax =" + totaltax);
    }
}

chevron_right


Output:

Enter the state name
Punjab
Total tax = 5000.0

References:
How to implement callback functions in Java?
Core Java: An Integrated Approach



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.