Implements onclicklistener android studio

Полный список

В этом уроке мы:

— научимся использовать один обработчик для нескольких View-элементов
— научим Activity выступать в качестве обработчика

Создадим проект:
Project name: P0101_Listener
Build Target: Android 2.3.3
Application name: Listener
Package name: ru.startandroid.develop.listener
Create Activity: MainActivity

Будем работать с теми же View, что и в предыдущем уроке. Код для main.xml:

Один обработчик для двух кнопок

Итак, у нас есть TextView с текстом и две кнопки. Как и на прошлом уроке, мы сделаем так, чтобы по нажатию кнопки менялось содержимое TextView. По нажатию кнопки OK – будем выводить текст: «Нажата кнопка ОК», по нажатию Cancel – «Нажата кнопка Cancel». Но сейчас мы сделаем это с помощью одного обработчика, который будет обрабатывать нажатия для обеих кнопок.

Напомню механизм обработки событий на примере нажатия кнопки. Сама кнопка обрабатывать нажатия не умеет, ей нужен обработчик (listener), который присваивается с помощью метода setOnClickListener. Когда на кнопку нажимают, обработчик реагирует и выполняет код из метода onClick.

Соответственно для реализации необходимо выполнить следующие шаги:
— создаем обработчик
— заполняем метод onClick
— присваиваем обработчик кнопке

В нашем случае мы будем присваивать один обработчик обеим кнопкам, а внутри обработчика надо будет определять, какая именно кнопка была нажата.

Подготовим объекты и создадим обработчик:

Давайте заполнять метод onClick. На вход ему подается объект класса View, это как раз то, что нам нужно. Это View, на которой произошло нажатие, и, которая вызвала обработчик. Т.е. в нашем случае это будет либо кнопка OK либо Cancel. Нам осталось узнать ID этой View и сравнить его с нашими R.id.btnOk и R.id.btnCancel, чтобы определить какая именно это кнопка. Чтобы получить ID какой-либо View, используется метод getId. Для перебора результатов используем java-оператор switch.

Реализация метода onClick:

Если сейчас запустить приложение и проверить, то ничего не произойдет. Обработчик то мы создали, но не присвоили его кнопкам. Обеим кнопкам присваиваем один и тот же обработчик:

Вот теперь можем запускать и проверять, все должно работать.

Как вы понимаете, один обработчик может быть присвоен не двум, а любому количеству кнопок. И не только кнопкам. У остальных View-элементов тоже есть различные события, которые нуждаются в обработчиках. В дальнейшем мы еще будем с ними работать. А сейчас важно понять схему, как происходит обработка событий.

Отличие способа реализации на этом уроке от прошлого урока в том, что сейчас мы создали один объект-обработчик для обеих кнопок, а на прошлом уроке — два объекта, по одному каждой кнопке. Есть правило – чем меньше объектов вы создаете, тем лучше, т.к. под каждый объект выделяется память, а это достаточно ограниченный ресурс, особенно для телефонов. Поэтому создавать один обработчик для нескольких View это правильнее с точки зрения оптимизации. К тому же кода становится меньше и читать его удобнее.

Есть еще один способ создания обработчика, который вовсе не потребует создания объектов. Будет использоваться уже созданный объект – Activity

Activity, как обработчик

Кнопка присваивает себе обработчика с помощью метода setOnClickListener (View.OnClickListener l). Т.е. подойдет любой объект с интерфейсом View.OnClickListener. Почему бы классу Activity не быть таким объектом? Мы просто укажем, что Activity-класс реализует интерфейс View.OnClickListener и заполним метод onCreate.

Создадим для этого новый проект:
Project name: P0102_ActivityListener
Build Target: Android 2.3.3
Application name: ActivityListener
Package name: ru.startandroid.develop.activitylistener
Create Activity: MainActivity

Экран снова возьмем тот же самый:

Подготовим объекты и добавим реализацию интерфейса (implements onClickListener)

OnClickListener подчеркнут красным, т.к. его нет в импорте. Поэтому CTRL+SHIFT+O и выбираем View.OnClickListener.

Теперь Eclipse ругается на класс MainActivity. Это происходит потому, что для класса прописан интерфейс, но нет реализации методов этого интерфейса. Исправим это с помощью Eclipse. Наведите курсор на MainAcivity и выберите Add unimplemented methods

Eclipse добавит знакомый нам метод onClick. Только теперь этот метод будет реализован в Activity, а не в отдельном объекте-обработчике. Соответственно Activity и будет выступать обработчиком.

Заполним метод точно так же как и раньше. Ничего не изменилось. Ему на вход так же подается View (на которой произошло событие), по Id мы определим, какая именно эта View и выполним соответствующие действия:

Осталось в методе onCreate присвоить обработчик кнопкам. Это будет объект this, т.е. текущий объект MainActivity.

При такой реализации мы не создали ни одного лишнего объекта (Activity создается в любом случае) и затраты памяти минимальны, это рекомендуемый метод. Но, возможно, такой способ покажется сложным и непонятным, особенно если мало опыта в объектно-ориентированном программировании. В таком случае используйте ту реализацию, которая вам понятна и удобна. А со временем и опытом понимание обязательно придет.

Самая простая реализация обработчика

Есть еще один способ реализации. В layout-файле (main.xml) при описании кнопки пишем:

Т.е. используем атрибут onClick. В нем указываем имя метода из Activity. Этот метод и сработает при нажатии на кнопку.

Далее, добавляем этот метод в Activity (MainActivity.java). Требования к методу: public, void и на вход принимает View:

В методе прописываете необходимые вам действия, и они будут выполнены при нажатии кнопки.

Присоединяйтесь к нам в Telegram:

— в канале StartAndroid публикуются ссылки на новые статьи с сайта startandroid.ru и интересные материалы с хабра, medium.com и т.п.

— в чатах решаем возникающие вопросы и проблемы по различным темам: Android, Kotlin, RxJava, Dagger, Тестирование

— ну и если просто хочется поговорить с коллегами по разработке, то есть чат Флудильня

— новый чат Performance для обсуждения проблем производительности и для ваших пожеланий по содержанию курса по этой теме

Источник

Android Practice

Статьи о разработке Android приложений

Установка OnClickListener и обработка нажатий

Когда мы имеет дело с множеством кнопок в приложении, то нужно позаботиться об обработке событий. В данной статье мы рассмотрим работу с OnClickListener , варианты создания разных обработчиков событий и возможные пути идентификации конкретной кнопки. Так же мы рассмотрим преимущества и недостатки этих подходов , в некоторых случая они очень существенны, а в некоторых нет.

Для установки обработчика для кнопки, используется setOnClickListener метод. В параметре передается класс реализующий OnClickListener интерфейс, который имеет единственный метод onClick(View v) . Установку обработчика для кнопок следует выполнять в onCreate() методе Activity.

Анонимный класс

Самый простой способ создания обработчика это использование анонимного класса.

Преимуществом такого подхода является простота и не требует создания дополнительных переменных. Очень хорошо подходит, если у вас только одна кнопка. Недостатками является внутренняя реализация, обработчик нельзя задать в другом месте и при наличии нескольких кнопок, такой подход становиться массивным. Так же недостатком является то, что обработчик будет использоваться только данной кнопкой.

Поле типа OnClickListener

Вместо анонимного класса мы может определить поле с типа OnClickListener и сразу же его инициализировать:

Здесь мы получает одновременное определение и реализацию. Далее созданное поле можно передать кнопке в качестве обработчика:

По сравнению с анонимными классом, использовать поле типа OnClickListener более удобнее. Преимуществом является легкая установка обработчика сразу нескольким кнопкам и одновременное определение с реализацией. Реализация может располагаться в любом месте. Недостатком является создание поля, а именно экземпляра класса и при этом, он может иметь другие методы, но они будут не видны из вне.

Вложенный класс

При таком подходе создается вложенный класс реализующий OnClickListener интерфейс:

После создание класса обработчика, его можно установить для каждой кнопки следующим образом:

Преимуществом является простая установка в setOnClickListener методе и то, что класс может иметь другие методы, к которым можно обращается. Недостатком является обязательное определение класса и отведение отдельного поля для хранения созданного экземпляра.

Activity с реализацией OnClickListener

Activity может сама реализовывать интерфейс OnClickListener , тогда при установки обработчика передается this . Сначала нужно сообщить, что Activity будет реализовывать интерфейс:

Чтобы установить обработчик, нужно передать this нашей Activity в качестве параметра:

Если с кнопкой в дальнейшем не производиться никаких действий, то можно не создавать ее экземпляр и установка обработчика будет следующей:

Если нужно установить обработчик во внутреннем классе, то нужно передать в качестве параметра MainActivity.this .

Такой подход обработки нажатий более простой, удобный и наиболее предпочтительный, а так же не создает дополнительных полей или классов.

Использование одного обработчика

Было бы не разумно создавать для каждой кнопки свой обработчик, а постараться использовать уже созданный. Для определения конкретной нажатой кнопки, можно использовать getId() метод. Этот метод будет возвращать идентификатор нажатой кнопки, а мы сможем выполнить дальнейшею логику соответственно кнопки:

Вы можете использовать фигурные скобки для лучшего разделения кода:

Рассмотренные подходы обработки нажатий можно применять не только для кнопок, но и для других элементов, например таких как ListView и GridView.

Источник

Button Click Me setOnClickListener Method Working — Java Android

Button will respond to OnClickListener after this course.

This example demonstrates the implement button onclicklistener android java Code Example

In this article, we will discuss about how to trigger click events on android Views (Buttons, Text views etc) ?

Android Button in JAVA ANDROID

Action listeners are probably the easiest — and most common — event handlers to implement. You implement an action listener to define what should be done when an user performs certain operation.

Step 1 − Create a new project in Android Studio, go to File ⇒ New Project and fill all required details to create a new project.

Create Empty Project

How to implement on Android Button OnClick in android programmatically.

S tep 2 — “Add the following code to res/layout/activity_main.xml.“

I worked in simple relative layout method for only give basic example.

• In the below code, we have declared Button as ”@+id/button”.
• You can add a spinner to your layout with the Button object. You should usually do so in your XML layout with a element. For example:

Источник

Обработка нажатия на отдельный View в элементе списка

В этой статье я опишу способ обработки нажатия на отдельную часть элемента списка. Кого заинтересовало, прошу под кат.

ПРЕДИСТОРИЯ

Недавно передо мной встала задача: реализовать возможность нажатия на отдельный View в элементе списка. Сложность заключалась в том, что метод onListItemClick() вызывается при нажатии на любую часть элемента списка (неважно, какой View находится под пальцем). Поискав решение, я ничего полезного не нашёл. Проведя несколько экспериментов, я всё-таки достиг цели.

СОЗДАНИЕ ПРОЕКТА

Создадим проект. Имя, пакет, версия ANDROID – на ваше усмотрение. Сначала разметка для элемента списка и Activity:

Я специально использую ListActivity, чтоб сократить урок. Использовать мы будем, разумеется, свой кастомный адаптер. Чтобы не морочиться с SimpleAdapter и его ArrayList > или BaseAdapter с его обязательными методами, я наследую свой адаптер от ArrayAdapter. Я не стал добавлять ViewHolder – он нам сейчас не нужен. Ну и наконец-то, сам код адаптера:

Давайте разбираться, что мы здесь накодили. В методе getView(int position, View convertView, ViewGroup parent) мы создаём вьюху для каждого элемента списка и там же находим кнопку и присваиеваем ей обработчик нажатия. Когда кнопку нажимают, появляется тост с позицией этого элемента. Как видите, всё очень просто! Правда, при этом почему-то перестаёт работать onListItemClick(ListView l, View v, int position, long id) (по крайней мере у меня). Поэтому придётся кодить обработку нажатия на нужную кнопку и на все остальные View в самом адаптере :(. Но можно сделать, как я написал выше — присвоить всем элементам OnClickListener, а потом смотреть — если наша кнопка, то одно действие, иначе — другое. А ещё лучше вынести все другие вьюхи в отдельный LinearLayout или RelativeLayout и присваивать слушатель только ему.

Ну вот в общем-то и всё. Буду рад, если этот пост поможет кому-нибудь.

Источник

Лучший способ реализовать View.OnClickListener в android

Предположим, что у нас есть Activity с большим количеством просмотров, на который должен регистрироваться OnClickListener .

Наиболее распространенный способ реализовать это – позволить Activity-Subclass реализовать OnClickListener, что-то вроде этого:

Способ, которым я его реализую, – создать частный класс внутри подкласса Activity и позволить этому внутреннему классу реализовать OnClickListener:

Таким образом, код выглядит более организованным и простым в обслуживании.

Более того, говоря о связях «Is-a», «Has-a», последнее кажется хорошей практикой, потому что теперь подкласс Activity-Subclass будет иметь отношение «Has-a» к ClickListener. Хотя в первом методе мы будем говорить, что наш подкласс «Подход» «Is-a» ClickListener, который не совсем прав.

Обратите внимание, что я не занимаюсь служебными данными памяти, которые это вызвало бы.

Кроме того, добавление тега onClick в xml полностью исключается.

Итак, что на самом деле является лучшим способом реализации ClickListener?

Пожалуйста, не предлагайте какие-либо библиотеки, такие как RoboGuice или ButterKnife и т. Д.

ОБНОВИТЬ:

Я хотел бы поделиться подходом, который я наконец принял.

Я непосредственно реализую слушателя в Activity / Fragment.

Что касается дизайна ООП. Подход «HAS-A» не дает никаких практических преимуществ и даже занимает больше памяти. Учитывая количество вложенных классов (и накладных расходов на память), которые мы будем создавать для каждого подобного слушателя, который мы реализуем, этот подход следует явно избегать.

Во-первых, нет никакой лучшей практики, определяемой Android относительно регистрации прослушивателей кликов. Это полностью зависит от вашего варианта использования.

Реализация интерфейса View.OnClickListener для Activity – это путь. Поскольку Android настоятельно рекомендует реализацию интерфейса снова и снова, является ли это Activity или Fragment.

Теперь, как вы описали:

Это ваш подход. Теперь это ваш способ реализации, и в этом нет ничего плохого, если вы не беспокоитесь об издержках памяти. Но в чем преимущество создания внутреннего класса и реализации View.OnClickListener если вы можете просто реализовать это в основном классе, что также может привести к ясности и простоте кода, которые вам нужны.

Таким образом, это просто обсуждение, которое позволяет получить наилучшее возможное решение для реализации View.OnClickListener, потому что, если вы пойдете с практической точки зрения, вы пойдете на решение, которое просто и эффективно.

Поэтому я предпочел бы обычный способ. Он держит вещи простыми и эффективными. Проверьте код ниже:

PS: Ваш подход определенно увеличит количество строк кода: P;)

Прежде всего, давайте рассмотрим основы здесь.

Внедряя интерфейс, ваш класс не станет таким .. как вы сказали:

«Наша активность-подкласс» Is-a «ClickListener, что не совсем так».

У вашего класса может быть только отношение «Is-a», если оно распространяется, в данном случае Activity . Реализация интерфейса означает, что он может вести себя так же, как интерфейс установил свой контракт.

Класс Питер расширяет Человека .. означает, что Питер – человек.

Класс Питер может также реализовать программиста, музыканта, мужа и т. Д., Что Питер может вести себя как выше.

Что касается лучшей практики, вы можете сделать совершенно отдельный класс, который реализует OnClickListener следующим образом:

И в своей основной Activity вы можете создать экземпляр MyListener и вызвать onClick() и передать в нем свое представление:

Я использую button.setOnClickListener(this); Где моя Activity implements View.OnClickListener , а затем получает идентификатор Button в отдельном методе. Ниже приведен пример:

Я нашел использование Butterknife для чистого кода. И поскольку он использует генерацию кода (а не отражения), он имеет незначительные накладные расходы.

Здесь вы можете создать объект btnClickListner, после чего вы будете называть этот объект btnCLickLisner, когда захотите выполнить действия onCLieck для кнопок.

Предположим, что в моей деятельности у меня есть от 5 до 10 кнопок, и каждая кнопка каждого отдельного onclick listner – плохая идея. Чтобы это произошло, мы можем использовать, как показано ниже.

Зарегистрируйте свои кнопки

Здесь я устанавливаю onclick listner на мои кнопки после нажатия

Вот реализация btnClick Listner

Ваш ClickListener – это внутренний нестатический класс, связанный с этим «has-a» ничем не отличается от того, что ваш класс Activity реализовал View.OnClickListener . Это потому, что ваш внутренний ClickListener требует экземпляра ActivityMain и действительно не может быть повторно использован. Я бы сказал, что вы закончили инженерную деятельность и на самом деле ничего не набираете.

EDIT: Чтобы ответить на ваш вопрос, мне нравится иметь анонимный View.OnClickListener для каждого виджета. Я думаю, что это создает лучшее разделение логики. У меня также есть такие методы, как setupHelloWorldTextView(TextView helloWorldTextView); Где я поместил всю свою логику, связанную с этим виджетами.

Первый подход лучше, чем другой, потому что именно поэтому View.OnClickListener является Interface вместо abstract class . Кроме того, позже может произойти утечка в различных ситуациях, так как вы используете нестатический внутренний класс.

В этом конкретном случае я бы сказал, что поддерживать единственный экземпляр OnClickListener – лучший подход для вас. У вас будет отношение «Has-a», и вам не нужно будет создавать несколько экземпляров, так как вы обрабатываете поведение, используя идентификатор вида в onClick(View view) .

Просто вы используете, как не реализуете подкласс или не обрабатываете событие click, просто делайте это так.

И обрабатывать событие click в кнопку ya любой тип события click, например

Его работа очень просто Спасибо

Это действительно зависит от того, чего вы хотите достичь. Если у вас есть, например, сложная функциональность с потоками, зависимостями и т. Д., Мне лично нравится полностью отделить ее от Activity в отдельный класс XyzAction , который делает тяжелый материал, знает о некоторых Invoker и возвращает их результаты, если это необходимо. My Invoker s – это в основном объекты, которые реализуют OnClick / OnTouch / etc. Listener и привязываются к необходимым действиям. Например, может быть LoginInvoker реализующий OnClickListener для Button и ImageView а также общий ActionListener который вызывается при нажатии на MenuItem . У Invoker есть методы обновления для отображения прогресса пользователю и результата связанного действия. Сообщения о действиях обновляются до его Invoker и могут быть собраны в мусор, если все они умирают, потому что у него нет связи с пользовательским интерфейсом.

Для менее сложных действий я связываю их непосредственно с компонентом Android (например, Activity / Feagment / View ), а также вызывают их Actions , с большой разницей в том, что они непосредственно выполняют обратные вызовы пользовательского интерфейса.

В обоих случаях я объявляю действия как члены, поэтому я могу быстро взглянуть на конкретные действия, которые поддерживает Android-компонент.

Если есть что-то тривиальное, например, «показывать нажатой кнопку« Toast », я использую анонимные внутренние классы для обратных вызовов пользовательского интерфейса, потому что вам обычно не очень-то интересно о них в отношении ремонтопригодности.

Небольшое замечание к этому и, возможно, немного темы.

Что, если мы не просто реализуем OnClickListener, и у нас есть куча других Listeners / Callback для реализации. В моем мнении он станет беспорядочным, чтобы реализовать все это в классе вместо использования анонимных классов / lambda. Трудно вспомнить, какой метод принадлежит интерфейсу.

Поэтому, если нам нужно реализовать интерфейс (в данном случае OnClickListener) несколько раз, это будет хорошим решением для реализации на базе классов и использования ключа switch / case.

Но если нам нужно реализовать несколько интерфейсов, это может быть хорошим решением для использования анонимных классов / лямбда

Вы можете использовать android:onClick=»btn» свойство Button в XML-файле, а затем в java-файле вам не нужно искать идентификатор кнопки. Вам просто нужно сделать одну функцию:

Помните, что вы должны указать одно и то же имя для имени onClick и имени функции.

Источник