Ответ 1

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

Вопрос 2: Я считаю, что в основном используются два и # 3. В качестве примера я использую кнопку 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. Кажется очень аккуратным и аккуратным, что все, что связано с этим щелчком мыши ButtonButton, находится здесь.

Кон, который комментирует мой коллега, заключается в том, что вы представляете, что у вас много просмотров, которым нужен прослушиватель onclick. Вы можете видеть, что ваш 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. Но недостатком, который я вижу, является то, что:

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

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

Ответ 2

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

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

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

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

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

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

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

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

Ответ 3

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

    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

Я предпочитаю вариант 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 сложнее.

Ответ 5

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

Ответ 6

Мой образец, протестированный в студии 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***/
        }
    });
}

Ответ 7

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

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

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

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

Ответ 8

Шаг 1: Creata 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