РЕДАКТИРОВАТЬ: я пишу Kotlin в моей повседневной работе, я на самом деле не компилировал примеры Java ниже, поэтому могут быть некоторые синтаксические ошибки.Тем не менее, это должно быть довольно тривиально, чтобы решить эти проблемы с базовыми знаниями Java.Концепции в этом ответе применимы к подавляющему большинству ОО-языков (Kotlin, Java, C # и т. Д.).
Я обновляю этот ответ, чтобы дать более подробную информацию о том, что такое интерфейс, почему ониполезно, как работают обратные вызовы и как они реализованы под капотом.
В объектно-ориентированном программировании (ОО) и, в данном случае, Java;Существует система типов, которая учитывает полиморфизм.Полиморфизм, когда он разбит, означает (поли -> многие) и (морфизм -> ведет себя как), или, другими словами, многие похожие типы поведения ведут себя одинаково.
Что это означает в более конкретных терминах кодирования, так это то, чтоу вас может быть много разных классов типов, которые соответствуют общему поведению (или интерфейсу).Поведение типа следует рассматривать как внешне наблюдаемое поведение, а не внутреннюю реализацию.Полезно осмыслить это в отношении системы типов.Например, поведение определяется как преобразование из одного типа в другой (например, функция, которая принимает коллекцию строк и возвращает строку).Существует много функций, которые могут выполнять это преобразование, но внешне наблюдаемое поведение всех этих функций одинаково (другими словами, преобразование Collection -> String).
Следовательно, из этого следует, что такая система типовможет допускать произвольную замену реализаций, пока поддерживается внешне наблюдаемое поведение.
Интерфейсы - это популярная языковая конструкция для достижения этой цели.Интерфейс просто определяет преобразования между типами и дает им имена.Другие типы могут затем зависеть от этого интерфейса и вызывать методы этого интерфейса, не заботясь о фактической реализации методов (единственное ограничение заключается в том, что разработчики указанного интерфейса должны соответствовать преобразованиям типов - это применяется во время компиляции вJava).
Вот очень простой интерфейс:
public interface Car {
public Int accelerate(Int force);
public Int steer(Int direction);
}
Я использую пример автомобиля, поскольку он довольно интуитивно понятен.Здесь мы видим два преобразования типа: от Int -> Int с именем accelerate и от Int -> Int с именем steer.
Все машины могут accelerate и steer.Но не все машины accelerate и steer одинаково.Тем не менее, все модели поведения автомобилей steer и accelerate следуют общему шаблону (или трансформации типа).Они принимают некоторое входное значение и приводят к некоторому выходному значению.
Итак, мы могли бы предоставить несколько реализаций автомобиля следующим образом (имейте в виду, что это очень надуманный пример, поэтому не судите):
public class Ford implements Car {
@Override
public Int accelerate(Int force) {
return force * 1;
}
@Override
public Int steer(Int direction) {
return direction * 1;
}
}
public class Ferrari implements Car {
@Override
public Int accelerate(Int force) {
return force * 10;
}
@Override
public Int steer(Int direction) {
return direction * 10;
}
}
Как видите,Форд и Феррари и управляют и ускоряются.Но Ferrari делает это по-другому (но он по-прежнему соответствует преобразованию типов так же, как и Ford).
Теперь мы представляем полиморфизм, который является очень мощным инструментом.Представьте, что у нас есть следующий класс:
public class Person {
private Car car;
public Person(Car car) {
this.car = car
}
}
Итак, человека можно построить, передав ему автомобиль в качестве зависимости.Из-за полиморфизма мы можем передать любой экземпляр объекта, который реализует (или соответствует) интерфейс Car.Например, мы могли бы сделать следующее:
public class Main {
public void main([String] args) {
Person poorPerson = new Person(new Ford());
Person richPerson = new Person(new Ferrari());
}
}
Довольно изящно!Теперь мы можем создавать сотни различных типов автомобилей, но класс нашего человека никогда не должен меняться!Наш персональный класс может вызывать методы на принадлежащих им автомобилях, и ему никогда не придется беспокоиться о том, что что-нибудь сломается (потому что все машины могут ускоряться и поворачиваться).
Итак, как это относится к исходному вопросу?Давайте рассмотрим этот очень надуманный пример класса Android View и интерфейса обратного вызова:
public interface ContrivedCallback {
public void onClick();
}
public class ContrivedView {
private ContrivedCallback callback;
public void setOnClickListener(ContrivedCallback: callback) {
this.callback = callback;
}
private void onClick() {
this.callback.invoke();
}
}
Предположим, что метод onClick в классе ContrivedView магически вызывается ОС Android при нажатии на представление.Теперь при щелчке по представлению вызывается обратный вызов (если установлен).Но, как мы теперь знаем, обратный вызов - это просто интерфейс, поэтому будет вызываться любая реализация, предоставленная методу setCallback.
Итак, единственный определенный метод обратных вызовов - это просто преобразование из Void -> Void (другими словами, он не принимает аргументов и не возвращает значения).Это просто какой-то код для запуска.Реализация может запускать ракеты, сохранять в базе данных, печатать строки или ничего не делать, это зависит от кодера, обеспечивающего реализацию).
Надеюсь, это имеет смысл?Теперь по отношению к первоначальному вопросу:
Вы можете использовать обратный вызов onClickListener.В этой реализации обратного вызова вы можете написать некоторый код, который обновит некоторое состояние действия или фрагмента (или записать в настройки или локальную базу данных, или запустить ракеты ... вы получите картинку).
Вы создаете реализацию изатем назначьте эту реализацию прослушивателю обратного вызова для рассматриваемой кнопки следующим образом (в вашем методе onCreate):
logoutButton = (Button)findViewById(R.id.logoutButton);
logoutButton.addOnClickListener(class callback extends DialogInterface.OnClickListener {
@Override
public void onClick() {
// Do stuff here...
}
});