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.
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)
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:
The following is the implementation 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:
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 ‘STax 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:
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.
Java interface for callback
Одним из распространенных способов использования интерфейсов в Java является создание обратного вызова. Суть обратного вызова состоит в том, что мы создаем действия, которые вызываются при других действиях. То есть одни действия вызываются другими действиями. Стандартный пример — нажатие на кнопку. Когда мы нажимаем на кнопку, мы производим действие, но в ответ на это нажатие запускаются другие действия. Например, нажатие на значок принтера запускает печать документа на принтере и т.д.
Рассмотрим следующий пример:
public class EventsApp < public static void main(String[] args) < Button button = new Button(new ButtonClickHandler()); button.click(); button.click(); button.click(); >> class ButtonClickHandler implements EventHandler < public void execute()< System.out.println("Кнопка нажата!"); >> interface EventHandler < void execute(); >class Button < EventHandler handler; Button(EventHandler action)< this.handler=action; >public void click() < handler.execute(); >> Итак, здесь у нас определен класс Button, который в конструкторе принимает объект интерфейса EventHandler и в методе click (имитация нажатия) вызывает метод execute этого объекта.
Далее определяется реализация EventHandler в виде класса ButtonClickHandler . И в основной программе объект этого класса передается в конструктор Button. Таким образом, через конструктор мы устанавливаем обработчик нажатия кнопки. И при каждом вызове метода button.click() будет вызываться этот обработчик.
В итоге программа выведет на консоль следующий результат:
Кнопка нажата! Кнопка нажата! Кнопка нажата!
Но казалось бы, зачем нам выносить все действия в интерфейс, его реализовать, почему бы не написать проще сразу в классе Button:
Дело в том, что на момент определения класса нам не всегда бывают точно известны те действия, которые должны производиться. Особенно если класс Button и класс основной программы находятся в разных пакетах, библиотеках и могут проектироваться разными разработчиками. К тому же у нас может быть несколько кнопок — объектов Button и для каждого объекта надо определить свое действие. Например, изменим главный класс программы:
public class EventsApp < public static void main(String[] args) < Button tvButton = new Button(new EventHandler()< private boolean on = false; public void execute()< if(on) < System.out.println("Телевизор выключен.."); on=false; >else < System.out.println("Телевизор включен!"); on=true; >> >); Button printButton = new Button(new EventHandler() < public void execute()< System.out.println("Запущена печать на принтере. "); >>); tvButton.click(); printButton.click(); tvButton.click(); > > Здесь у нас две кнопки — одна для включения-выключения телевизора, а другая для печати на принтере. Вместо того, чтобы создавать отдельные классы, реализующие интерфейс EventHandler, здесь обработчики задаются в виде анонимных объектов, которые реализуют интерфейс EventHandler. Причем обработчик кнопки телевизора хранит дополнительное состояние в виде логической переменной on .
В итоге консоль выведет нам следующий результат:
Телевизор включен! Запущена печать на принтере. Телевизор выключен..
И в завершении надо сказать, что интерфейсы в данном качестве особенно широко используются в различных графических API — AWT, Swing, JavaFX, где обработка событий объектов — элементов графического интерфейса особенно актуальна.
Урок 13. Основы JAVA. Методы обратного вызова (callback)
Механизм обратного вызова(callbacks) широко распространен в программировании. При обратном вызове программист задает действия, которые должны выполняться всякий раз, когда происходит некоторое событие. И неважно, будете разрабатывать только java-программы или android-приложения – колбеки будут встречаться вам повсюду.
Для создания методов обратного вызова (callback) в java используются уже знакомые нам из прошлого урока интерфейсы.
import javax.swing.*; public class SomeClass < // создаем колбек и его метод interface Callback< void callingBack(); >Callback callback; public void registerCallBack(Callback callback) < this.callback = callback; >void doSomething() < JOptionPane.showMessageDialog(null, "Выполняется работа"); // вызываем метод обратного вызова callback.callingBack(); >>
У интерфейса мы определили один метод callingBack(). Далее в классе мы создали объект интерфейса и инициализировали его в методе registerCallBack. В классе также был создан метод doSomething(), в котором может содержаться какой-то сложный код. Мы здесь создаем диалоговое окно, используя компонент JOptionPane библиотеки Swing. Кто не в курсе, Swing — библиотека для создания графического интерфейса программ на языке Java.
В конце работы метода doSomething() вызывается метод интерфейса callingBack() . В данном случае мы сами создали метод и знаем его код. Но во многих случаях, вы будете использовать готовый метод какого-то класса и можете даже не знать, что именно содержится в этом методе. Вам надо только знать, что такой метод существует и выполняет конкретную задачу.
Теперь нам нужен класс, реализующий интерфейс-callback. Создаем класс MyClass и подключаем интерфейс-колбек через ключевое слово implements. Среда разработки заставит нас реализовать шаблон метода интерфейса.
public class MyClass implements SomeClass.Callback < @Override public void callingBack() < System.out.println("Вызов метода обратного вызова"); >> Теперь мы можем использовать метод обратного вызова callingBack () для решения своих задач. Будем здесь выводить текст в консоль. Создадим класс Main, в котором будет реализован метод main – точка входа в программу.
Здесь создаем экземпляры классов, инициализируем колбек, передавая методу registerCallBack экземпляр MyClass, реализующий интерфейс-callback. И вызываем метод doSomething();
При старте программы будет выполняться код метода doSomething(); из класса SomeClass. На экране появилось диалоговое окно.
Когда мы нажмем кнопку, или закроем диалоговое окно, сработает метод обратного вызова callingBack(), который выведет сообщение в консоль.
package callback; import javax.swing.*; public class SomeClass < String replyTo; interface Callback< void callingBack(String s); >private Callback callback; public void registerCallBack(Callback callback) < this.callback = callback; >void doSomething() < int reply = JOptionPane.showConfirmDialog(null, "Вы программист?", "Опрос", JOptionPane.YES_NO_OPTION); if (reply == JOptionPane.NO_OPTION)< replyTo = "Нет"; >if (reply == JOptionPane.YES_OPTION) < replyTo = "Да"; >callback.callingBack(replyTo); > >
Изменим диалоговое окно – присвоим его новой целочисленной переменной reply, и изменим на showConfirmDialog, который имеет заголовок окна и больше одной кнопки ответа. В зависимости от нажатой кнопки переменной reply будет присвоено значение. Сравниваем ее значение с константой и присваиваем значение “Да” или “Нет” переменной replyTo.
package callback; public class MyClass implements SomeClass.Callback < @Override public void callingBack(String s) < if (s != null) < System.out.println("Ваш ответ: " + s); >else < System.out.println("Вы не ответили на вопрос!"); >> > Добавим аргумент в метод. И добавим условие проверки, что строка не пустая – это возможно, если вместо ответа просто закрыть диалоговое окно.
package callback; public class Main < public static void main(String[] args) < SomeClass someClass = new SomeClass(); MyClass myClass = new MyClass(); someClass.registerCallBack(myClass); someClass.doSomething(); >>
Запускаем программу. Теперь текст сообщения в консоли меняется в зависимости от того, выберем мы да, нет или просто закроем окно.
Я надеюсь, вы поняли принцип методов обратного вызова. Ниже есть ссылка на дополнительную информацию по колбекам, а также более сложные и познавательные примеры. Вопросы можно задавать в комментариях.
Callback using Interfaces in Java
In the case of Event-driven programming, we pass a reference to a function which will get called when an event occurs. This mechanism is termed as a callback. Java does not support function pointers. So we can not implement the same direction. But using interfaces we can achieve the same very easily.
In the example below, we’ve made a callback when a button is clicked. See the steps −
- Create an interface ClickEventHandler with a single method handleClick().
- Create a ClickHandler class which implements this interface ClickEventHandler.
- Create a Button class which will call ClickHandler when it’s click method is called.
- Test the application.
Example
//Step 1: Create an interface for the callback method interface ClickEventHandler < public void handleClick(); >//Step 2: Create a callback handler //implementing the above interface class ClickHandler implements ClickEventHandler < public void handleClick() < System.out.println("Clicked"); >> //Step 3: Create event generator class class Button < public void onClick(ClickEventHandler clickHandler) < clickHandler.handleClick(); >> public class Tester < public static void main(String[] args) < Button button = new Button(); ClickHandler clickHandler = new ClickHandler(); //pass the clickHandler to do the default operation button.onClick(clickHandler); Button button1 = new Button(); //pass the interface to implement own operation button1.onClick(new ClickEventHandler() < @Override public void handleClick() < System.out.println("Button Clicked"); >>); > > Output
Learning faster. Every day.