Android: как обращаться с кнопкой

Имея солидный опыт работы в не-Java и не-Android-области, я изучаю Android.

У меня много путаницы с разными областями, один из них – как управлять нажатиями кнопок. Есть как минимум 4 способа сделать это (!!!), они кратко перечислены здесь

Для цели согласования я перечислил их:

  1. Имейте член класса View.OnClickListener в View.OnClickListener и назначьте его экземпляру, который будет обрабатывать логику onCreate в onCreate активности onCreate .

  2. Создайте 'onClickListener' в методе активности onCreate и назначьте его кнопке с помощью setOnClickListener

  3. Внедрите «onClickListener» в самом действии и назначьте «это» в качестве слушателя для кнопки. В случае, если активность имеет несколько кнопок, идентификатор кнопки должен быть проанализирован для выполнения обработчика onClick для правильной кнопки

  4. Имейте общедоступный метод активности, который реализует логику «onClick» и назначает ее кнопке в объявлении xml активности

Вопрос 1:

Есть ли все эти методы, есть ли другой вариант? (Мне не нужны другие, просто любопытные)

Для меня самый интуитивный способ был бы самым последним: для этого требуется наименьшее количество кода и является наиболее читаемым (по крайней мере для меня).

Хотя, я не вижу, чтобы этот подход широко использовался. Что такое минусы для его использования?

Вопрос 2:

Каковы плюсы и минусы для каждого из этих методов? Поделитесь своим опытом или хорошей ссылкой.

Любая обратная связь приветствуется!

PS Я пытался Google и нашел что-то для этой темы, но единственное, что я нашел, – это описание «как» сделать это, а не почему это хорошо или плохо.

Вопрос 1: К сожалению, тот, в котором вы говорите, наиболее интуитивно понятен, наименее используется в Android. Насколько я понимаю, вы должны отделить свой пользовательский интерфейс (XML) и вычислительную функциональность (файлы классов Java). Это также упрощает отладку. На самом деле гораздо проще читать этот путь и думать об Android imo.

Вопрос 2: Я считаю, что в основном используются два и # 2. В качестве примера я использую кнопку ButtonButton.

2

Находится в форме анонимного класса.

 Button clickButton = (Button) findViewById(R.id.clickButton); clickButton.setOnClickListener( new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub ***Do what you want with the click here*** } }); 

Это мой любимый, поскольку он имеет метод onClick рядом с тем, где была установлена ​​переменная кнопки с помощью findViewById. Кажется очень аккуратным и аккуратным, что все, что имеет дело с этим clickButton Button View, находится здесь.

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

3

Скажем, у вас есть 5 кликов:

Убедитесь, что ваш Activity / Fragment реализует OnClickListener

 // in OnCreate Button mClickButton1 = (Button)findViewById(R.id.clickButton1); mClickButton1.setOnClickListener(this); Button mClickButton2 = (Button)findViewById(R.id.clickButton2); mClickButton2.setOnClickListener(this); Button mClickButton3 = (Button)findViewById(R.id.clickButton3); mClickButton3.setOnClickListener(this); Button mClickButton4 = (Button)findViewById(R.id.clickButton4); mClickButton4.setOnClickListener(this); Button mClickButton5 = (Button)findViewById(R.id.clickButton5); mClickButton5.setOnClickListener(this); // somewhere else in your code public void onClick(View v) { switch (v.getId()) { case R.id.clickButton1: { // do something for button 1 click break; } case R.id.clickButton2: { // do something for button 2 click break; } //.... etc } } 

Таким образом, как объясняет мой коллега, он аккуратен в глазах, так как все вычисления onClick обрабатываются в одном месте и не переполняют метод onCreate. Но недостатком, который я вижу, является то, что:

  1. Рассматривает себя,
  2. И любой другой объект, который может быть расположен в onCreate, используемом методом onClick, должен быть сделан в поле.

Дайте мне знать, если вам нужна дополнительная информация. Я не ответил на ваш вопрос полностью, потому что это довольно длинный вопрос. И если я найду несколько сайтов, я расширю свой ответ, прямо сейчас я просто даю некоторый опыт.

# 1 Я использую последнее часто, когда есть кнопки на макете, которые не сгенерированы (но, очевидно, статические).

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

Для архивирования какого-то времени компиляции с этим подходом взгляните на Android Lint ( пример ).


# 2 Плюсы и минусы для всех методов почти одинаковы, и урок должен быть:

Используйте то, что когда-либо наиболее подходит или чувствует себя наиболее интуитивно понятным для вас.

Если вам нужно назначить один и тот же OnClickListener для нескольких экземпляров кнопок, сохраните их в области класса (# 1). Если вам нужен простой прослушиватель для Button, выполните анонимную реализацию:

 button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { // Take action. } }); 

Я склонен не реализовывать OnClickListener в своей деятельности, это время от времени становится немного запутанным (особенно когда вы реализуете несколько других обработчиков событий, и никто не знает, что this все делает).

Наиболее используемый способ – анонимная декларация

  Button send = (Button) findViewById(R.id.buttonSend); send.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { // handle click } }); 

Также вы можете создать объект View.OnClickListener и установить его на кнопку позже, но вам по-прежнему необходимо переопределить метод onClick, например

 View.OnClickListener listener = new View.OnClickListener(){ @Override public void onClick(View v) { // handle click } } Button send = (Button) findViewById(R.id.buttonSend); send.setOnClickListener(listener); 

Когда ваша активность реализует интерфейс OnClickListener, вы должны переопределить метод onClick (View v) на уровне активности. Затем вы можете проверить эту активность как кнопку прослушивания на кнопку, поскольку она уже реализует интерфейс и переопределяет метод onClick ()

 public class MyActivity extends Activity implements View.OnClickListener{ @Override public void onClick(View v) { // handle click } @Override public void onCreate(Bundle b) { Button send = (Button) findViewById(R.id.buttonSend); send.setOnClickListener(this); } } 

(Imho) 4-й подход используется, когда несколько кнопок имеют один и тот же обработчик, и вы можете объявить один метод в классе активности и назначить этот метод нескольким кнопкам в макете xml, также вы можете создать один метод для одной кнопки, но в этом случае я Предпочитают объявлять обработчики внутри класса активности.

Я предпочитаю вариант 4, но он имеет для меня интуитивный смысл, потому что я слишком много работаю в Grails, Groovy и JavaFX. «Магические» соединения между представлением и контроллером являются общими. Важно хорошо назвать этот метод:

В представлении добавьте метод onClick к кнопке или другому виджету:

  android:clickable="true" android:onClick="onButtonClickCancel" 

Затем в классе обработайте метод:

 public void onButtonClickCancel(View view) { Toast.makeText(this, "Cancel pressed", Toast.LENGTH_LONG).show(); } 

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

Одно из преимуществ заключается в том, что теперь вы можете написать модульные тесты для этого метода. Вариант 1 может сделать это, но 2 и 3 сложнее.

Варианты 1 и 2 связаны с использованием внутреннего класса, который будет создавать код типа беспорядка. Вариант 2 довольно грязный, потому что для каждой кнопки будет один слушатель. Если у вас мало кнопки, это нормально. Для варианта 4 я думаю, что это будет сложнее отлаживать, так как вам придется вернуться, а четвертый – xml и java-код. Я лично использую параметр 3, когда мне приходится обрабатывать множественные нажатия кнопок.

Мой образец, протестированный в студии Android 2.1

Определить кнопку в XML-макете

 <Button android:id="@+id/btn1" android:layout_width="wrap_content" android:layout_height="wrap_content" /> 

Обнаружение пульсации Java

 Button clickButton = (Button) findViewById(R.id.btn1); if (clickButton != null) { clickButton.setOnClickListener( new View.OnClickListener() { @Override public void onClick(View v) { /***Do what you want with the click here***/ } }); } 

Вопрос № 1 – это единственный способ обработки кликов.

Вопрос 2 –
Вариант № 1 / Вариант № 4 – Между опцией №1 и опцией № 4 нет большой разницы. Единственное различие, которое я вижу, в одном случае – это реализация OnClickListener, тогда как в другом случае будет анонимная реализация.

Вариант №2 – в этом методе будет создан анонимный класс. Этот метод немного похож, так как вам нужно будет делать это несколько раз, если у вас несколько кнопок. Для анонимных классов вы должны быть осторожны при обращении с утечками памяти.

Вариант № 3 – Хотя, это простой способ. Обычно программисты стараются не использовать какой-либо метод, пока не напишут его, и, следовательно, этот метод широко не используется. Вы увидите, что большинство людей используют вариант №4. Потому что он чище с точки зрения кода.

Шаг 1. Создание файла XML

 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical"> <Button android:id="@+id/btnClickEvent" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Click Me" /> </LinearLayout> 

Шаг 2. Создание MainActivity

 package com.scancode.acutesoft.telephonymanagerapp; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.widget.Button; public class MainActivity extends Activity implements View.OnClickListener { Button btnClickEvent; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); btnClickEvent = (Button) findViewById(R.id.btnClickEvent); btnClickEvent.setOnClickListener(MainActivity.this); } @Override public void onClick(View v) { //Your Logic } } 

HappyCoding