devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android学习笔记（七）：按钮Button的常用方法_android写一个button

作者：羊村懒王 | 2024-04-27 01:58:42

赞

踩

android写一个button

目录

一、Button 与 TextView

二、xml添加点击事件监听

 三、java实现按钮点击事件监听

1、常用写法

2、非常用写法

四、监听长按按钮事件

五、按钮的使能

六、练习

七、总结

一、Button 与 TextView

  1. <TextView
  2.         android:layout_width="match_parent"
  3.         android:layout_height="wrap_content"
  4.         android:text="@string/text_view"
  5.         android:textSize="20sp" />
  6.  
  7. <Button
  8.         android:layout_width="match_parent"
  9.         android:layout_height="wrap_content"
  10.         android:text="@string/button_view"
  11.         android:textSize="20sp" />

/*
* 按钮控件Button由TextView派生而来，区别：
* Button有默认按钮背景，而TextView默认无背景；
* Button文本内容是默认居中，TextView默认左对齐；
* */

二、xml添加点击事件监听

        在xml中添加并不常用，因为我们提到，xml布局和java实现最好要低耦合，相关性不大，这样才有利于开发移植。但我们还是要去了解学习，这样别人写了我们也能看懂。

  1.     <Button
  2.         android:layout_width="match_parent"
  3.         android:layout_height="wrap_content"
  4.         android:onClick="doClick"
  5.         android:text="doClick"
  6.         android:textSize="20sp" />
  7.  
  8.     <TextView
  9.         android:id="@+id/current_time"
  10.         android:layout_width="match_parent"
  11.         android:layout_height="wrap_content"
  12.         android:text="@string/text_view"
  13.         android:textSize="25sp" />

        从代码中可以看到，添加了一个onClick属性，属性值为"doClick"，其含义就是：当我点击这个按钮时，就会去实现doClick()函数的内容，因此，在java实现中必须实现doClick函数； 其次，也添加了一个TextView来显示实现的内容。java部分代码如下所示。

  1. public class MainActivity extends AppCompatActivity {
  2.     private TextView mCurrentTime;
  3.  
  4.     @Override
  5.     protected void onCreate(Bundle savedInstanceState) {
  6.         super.onCreate(savedInstanceState);
  7.         setContentView(R.layout.activity_main);
  8.         initUI();
  9.     }
  10.  
  11.     private void initUI() {
  12.         mCurrentTime = findViewById(R.id.current_time);
  13.     }
  14.  
  15.     public void doClick(View view) {
  16.         // 点击按钮后实现的内容逻辑
  17.         flashText(view);
  18.     }
  19.  
  20.     private void flashText(View view) {
  21.         String currentTime = String.format("%s current time: %s",
  22.              ((Button) view).getText(), DateUtil.getCurrentTime());
  23.         mCurrentTime.setText(currentTime);
  24.     }
  25. }

        在MainActivity类中，实现的逻辑就是先加载xml布局，再实现doClick函数。其中需要注意的是：

1、在加载xml布局时，最好把它单独写一个函数，如initUI，我觉得这样写的话，可以增加可读性，因为如果需要添加的布局很多，这样在onCreate中就会写大量代码，而写在一个函数里，一眼就知道这个逻辑流程是什么；

2、mCurrentTime这个TextView我写成私有成员变量，这样可以很方便的对其进行操作；

3、我在doClick中调用了flashText()函数，整个逻辑就是在点击按钮时，mCurrentTime这个TextView显示内容就会被修改为按钮的text属性值和当前时间；

4、DateUtil.getCurrentTime() 这个是我实现的类和其方法来显示时间，代码如下：

  1. package com.example.texttest.Util;
  2.  
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;
  5.  
  6. public class DateUtil {
  7.  
  8.     public static String getCurrentTime() {
  9.         // "HH:mm:ss" 表示显示的时间格式；
  10.         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
  11.         return sdf.format(new Date());
  12.     }
  13. }

         最终的效果如下所示，点击按钮后，显示了doClick以及当前时间

 三、java实现按钮点击事件监听

1、常用写法

        首先，在xml布局文件中，我们添加一个Button布局，如下所示。因为要使用它，所以给它一个id。

  1.     <Button
  2.         android:id="@+id/button1"
  3.         android:layout_width="match_parent"
  4.         android:layout_height="wrap_content"
  5.         android:text="Button1"
  6.         android:textSize="20sp" />

        然后在java中实现对应的逻辑，部分代码如下

  1. public class MainActivity extends AppCompatActivity
  2.          implements View.OnClickListener {
  3.     private TextView mCurrentTime;
  4.     private Button mButton1;
  5.  
  6.     @Override
  7.     protected void onCreate(Bundle savedInstanceState) {
  8.         super.onCreate(savedInstanceState);
  9.         setContentView(R.layout.activity_main);
  10.         initUI();
  11.         setClickListener();
  12.     }
  13.  
  14.     private void initUI() {
  15.         mCurrentTime = findViewById(R.id.current_time);
  16.         mButton1 = findViewById(R.id.button1);
  17.     }
  18.  
  19.     private void setClickListener() {
  20.         // 设置事件监听
  21.         mButton1.setOnClickListener(this);
  22.     }
  23.  
  24.     @Override
  25.     public void onClick(View view) {
  26.         if (view.getId() == R.id.button1) {
  27.             // 点击按钮后实现的内容逻辑
  28.             flashText(view); 
  29.         }
  30.     }
  31.  
  32.     private void flashText(View view) {
  33.         String currentTime = String.format("%s current time: %s",
  34.              ((Button) view).getText(), DateUtil.getCurrentTime());
  35.         mCurrentTime.setText(currentTime);
  36.     }
  37. }

1、同样在initUI中加载对应的布局mButton1 = findViewById(R.id.button1)；且用同样的思维，添加一个setClickListener函数来统一设置事件监听逻辑；

2、需要让该类实现接口 implements View.OnClickListener ，实现接口onClick(View view)；

3、因为在该类中可能有多个按钮，所以要区分到底是点击了那个按钮，并实现对应按钮的逻辑；通过view.getId()来获取按钮id进行区分

        你可能会有疑惑，为什么需要实现View.OnClickListener这个接口，又为什么setOnClickListener(this) 传入的参数是this？下面就进行简单解答。

2、非常用写法

        首先我们通过看setOnClickListener函数源码可以看到，入参需要传递的是View.OnClickListener接口实例，因此，我们可以这样写代码逻辑：

  1. public class MainActivity extends AppCompatActivity {
  2.     private Button mButton1;
  3.  
  4.     @Override
  5.     protected void onCreate(Bundle savedInstanceState) {
  6.         super.onCreate(savedInstanceState);
  7.         setContentView(R.layout.activity_main);
  8.         initUI();
  9.         setClickListener();
  10.     }
  11.  
  12.     private void initUI() {
  13.         mCurrentTime = findViewById(R.id.current_time);
  14.         mButton1 = findViewById(R.id.button1);
  15.     }
  16.  
  17.     private void setClickListener() {
  18.         // 设置事件监听
  19.         mButton1.setOnClickListener(new MyOnClickListener());
  20.     }
  21.  
  22.     static class MyOnClickListener implements View.OnClickListener {
  23.         @Override
  24.         public void onClick(View view) {
  25.                 // 点击按钮后实现的内容逻辑
  26.             }
  27.         }
  28.     }
  29.  
  30. }

        代码中，首先实现了一个内部类MyOnClickListener，并且它实现接口View.OnClickListener和方法onClick；但是可以明显看到这样写的弊端，就是如果我需要多个按钮，岂不是要写多个内部类。

        因此，我们常采用第一种写法，让该类直接实现接口和方法，并通过id来区分不同的按钮，现在你也知道为什么传入的参数是this了吧，this指代的就是当前实现了View.OnClickListener接口的类的实例。

四、监听长按按钮事件

        按钮除了点击，还有长按操作，在按按钮低于500ms时触发点击事件，超过500ms时触发长按事件。 部分代码如下

  1. // xml
  2.     <Button
  3.         android:id="@+id/long_button"
  4.         android:layout_width="match_parent"
  5.         android:layout_height="wrap_content"
  6.         android:text="LongButton"
  7.         android:textSize="20sp" />
  8.  
  9. public class MainActivity extends AppCompatActivity
  10.          implements View.OnClickListener {
  11.     private Button mButton1;
  12.     private Button mLongButton;
  13.  
  14.     @Override
  15.     protected void onCreate(Bundle savedInstanceState) {
  16.         super.onCreate(savedInstanceState);
  17.         setContentView(R.layout.activity_main);
  18.         initUI();
  19.         setClickListener();
  20.     }
  21.  
  22.     private void initUI() {
  23.         mButton1 = findViewById(R.id.button1);
  24.         mLongButton = findViewById(R.id.long_button);
  25.     }
  26.  
  27.     private void setClickListener() {
  28.         // 设置事件监听
  29.         mButton1.setOnClickListener(this);
  30.         // 写法一
  31.         /*mLongButton.setOnLongClickListener(new View.OnLongClickListener() {
  32.             @Override
  33.             public boolean onLongClick(View view) {
  34.                 // 实现长按后的逻辑
  35.                 /*OnLongClickListener()会返回一个boolean值
  36.                 * 该值表示是否消耗这个点击事件
  37.                 * true表示消耗点击事件
  38.                 * false表示不消耗，那么该事件还可以传给它的父控件*/
  39.                 return true;
  40.             }
  41.         });*/
  42.         // 写法二：lambda
  43.         mLongButton.setOnLongClickListener(view -> {
  44.             flashText(view);
  45.             return true;
  46.         });
  47.     }
  48.  
  49.     @Override
  50.     public void onClick(View view) {
  51.         if (view.getId() == R.id.button1) {
  52.  
  53.         }
  54.     }
  55.  
  56. }

        在xml文件中还是一样的设置，在Java中同样的加载布局并设置事件监听（setOnLongClickListener），这个接口需要传入实现了OnLongClickListener这个接口的实例对象，并实现boolean onLongClick(View var1); 这个方法。我想你应用学会了通过前两种方式来实现设置长按事件监听，这里我再通过另一种写法（写法二：lambda）。

        此外OnLongClickListener()会返回一个boolean值，该值表示是否消耗这个点击事件，true表示消耗点击事件，false表示不消耗，那么该事件还可以传给它的父控件进行处理。

五、按钮的使能

        我们还可以给按钮设置是否使能，即设置该按钮是否可以点击，就比如当我们日常发生验证码时，在60s内无法再次发送，这个时候就是通过使能设置让按钮无法再进行点击。部分代码实现如下所示。xml中通过enabled属性设置使能状态，true为可点击，false为不可点击；也可以在java中通过setEnabled()设置使能状态。

  1. // xml
  2. <Button
  3.         android:id="@+id/button_test"
  4.         android:layout_width="match_parent"
  5.         android:layout_height="wrap_content"
  6.         android:text="Button Test"
  7.         android:enabled="false"
  8.         android:textSize="20sp" />
  9.  
  10. //java
  11. Button mButtonTest;
  12. mButtonTest = findViewById(R.id.button_test);
  13. mButtonTest.setEnabled(true);

六、练习

        这里给你们出了一个练习题，效果如下所示

        我们需要添加三个按钮（Button Enable/Button Disable/Button Test）和一个TextView（这里我直接使用的之前的），然后在Button Test默认使能false，不可点击，这时按钮背景为灰色，你可以像我一样，字体颜色也设置为灰色；当点击Button Enable设置Button Test可以点击，并点击Button Test按钮后在TextView中显示当前时间和哪个按钮；当点击Button Disable按钮时设置Button Test按钮不可点击。下面给出了我实现的APP的xml代码和java代码逻辑。

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:layout_width="match_parent"
  4.     android:layout_height="match_parent"
  5.     android:orientation="vertical"
  6.     android:padding="5sp">
  7.  
  8.     <TextView
  9.         android:layout_width="match_parent"
  10.         android:layout_height="wrap_content"
  11.         android:text="@string/text_view"
  12.         android:textSize="20sp" />
  13.  
  14.     <Button
  15.         android:layout_width="match_parent"
  16.         android:layout_height="wrap_content"
  17.         android:text="@string/button_view"
  18.         android:textSize="20sp" />
  19.  
  20.     <Button
  21.         android:layout_width="match_parent"
  22.         android:layout_height="wrap_content"
  23.         android:onClick="doClick"
  24.         android:text="doClick"
  25.         android:textSize="20sp" />
  26.  
  27.     <TextView
  28.         android:id="@+id/current_time"
  29.         android:layout_width="match_parent"
  30.         android:layout_height="wrap_content"
  31.         android:text="@string/text_view"
  32.         android:textSize="25sp" />
  33.  
  34.     <Button
  35.         android:id="@+id/button1"
  36.         android:layout_width="match_parent"
  37.         android:layout_height="wrap_content"
  38.         android:text="Button1"
  39.         android:textSize="20sp" />
  40.  
  41.     <Button
  42.         android:id="@+id/long_button"
  43.         android:layout_width="match_parent"
  44.         android:layout_height="wrap_content"
  45.         android:text="LongButton"
  46.         android:textSize="20sp" />
  47.  
  48.     <LinearLayout
  49.         android:layout_width="match_parent"
  50.         android:layout_height="wrap_content"
  51.         android:orientation="horizontal">
  52.  
  53.         <Button
  54.             android:id="@+id/button_enable"
  55.             android:layout_width="0dp"
  56.             android:layout_height="wrap_content"
  57.             android:layout_weight="1"
  58.             android:text="Button Enable"
  59.             android:textSize="20sp" />
  60.  
  61.         <Button
  62.             android:id="@+id/button_disable"
  63.             android:layout_width="0dp"
  64.             android:layout_height="wrap_content"
  65.             android:layout_weight="1"
  66.             android:text="Button Disable"
  67.             android:textSize="20sp" />
  68.  
  69.     </LinearLayout>
  70.  
  71.     <Button
  72.         android:id="@+id/button_test"
  73.         android:layout_width="match_parent"
  74.         android:layout_height="wrap_content"
  75.         android:text="Button Test"
  76.         android:enabled="false"
  77.         android:textSize="20sp" />
  78.  
  79. </LinearLayout>
  1. package com.example.texttest;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4.  
  5. import android.graphics.Color;
  6. import android.os.Bundle;
  7. import android.view.View;
  8. import android.widget.Button;
  9. import android.widget.TextView;
  10.  
  11. import com.example.texttest.Util.DateUtil;
  12.  
  13. public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  14. /*
  15. * 按钮控件Button由TextView派生而来，区别：
  16. * Button有默认按钮背景，而TextView默认无背景；
  17. * Button文本内容是默认居中，TextView默认左对齐；
  18. * */
  19.     private TextView mCurrentTime;
  20.     private Button mButton1;
  21.     private Button mLongButton;
  22.     private Button mButtonEnable;
  23.     private Button mButtonDisable;
  24.     private Button mButtonTest;
  25.     @Override
  26.     protected void onCreate(Bundle savedInstanceState) {
  27.         super.onCreate(savedInstanceState);
  28.         setContentView(R.layout.activity_main);
  29.         initUI();
  30.         setClickListener();
  31.     }
  32.  
  33.     private void initUI() {
  34.         mCurrentTime = findViewById(R.id.current_time);
  35.         mButton1 = findViewById(R.id.button1);
  36.         mLongButton = findViewById(R.id.long_button);
  37.         mButtonEnable = findViewById(R.id.button_enable);
  38.         mButtonDisable = findViewById(R.id.button_disable);
  39.         mButtonTest = findViewById(R.id.button_test);
  40.     }
  41.  
  42.     private void setClickListener() {
  43.         mButton1.setOnClickListener(this);
  44.         /*mLongButton.setOnLongClickListener(new View.OnLongClickListener() {
  45.             @Override
  46.             public boolean onLongClick(View view) {
  47.                 flashText(view);
  48.                 return true;
  49.             }
  50.         });*/
  51.         mLongButton.setOnLongClickListener(view -> {
  52.             flashText(view);
  53.             /*OnLongClickListener()会返回一个boolean值
  54.             * 该值表示是否消耗这个点击事件
  55.             * true表示消耗点击事件
  56.             * false表示不消耗，那么该事件还可以传给它的父控件*/
  57.             return true;
  58.         });
  59.         mButtonEnable.setOnClickListener(this);
  60.         mButtonDisable.setOnClickListener(this);
  61.         mButtonTest.setOnClickListener(this);
  62.     }
  63.  
  64.     public void doClick(View view) {
  65.         flashText(view);
  66.     }
  67.  
  68.     @Override
  69.     public void onClick(View view) {
  70.         if (view.getId() == R.id.button1) {
  71.             flashText(view);
  72.         }
  73.         else if (view.getId() == R.id.button_enable) {
  74.             mButtonTest.setEnabled(true);
  75.             mButtonTest.setTextColor(Color.WHITE);
  76.         }
  77.         else if (view.getId() == R.id.button_disable) {
  78.             mButtonTest.setEnabled(false);
  79.             mButtonTest.setTextColor(Color.GRAY);
  80.         }
  81.         else if (view.getId() == R.id.button_test) {
  82.             flashText(view);
  83.  
  84.         }
  85.     }
  86.  
  87.     private void flashText(View view) {
  88.         String currentTime = String.format("%s current time: %s", ((Button) view).getText(), DateUtil.getCurrentTime());
  89.         mCurrentTime.setText(currentTime);
  90.     }
  91. }

        所使用的xml布局设计和java逻辑通过前几章的学习和今天的学习，我相信你不仅可以读懂它，自己也可以独自实现它。 

七、总结

        在本章中，我们主要学习Button按钮控件的使用，包括添加按钮，设置按钮点击、长按事件监听（常用写法和非常用写法），以及设置按钮使能状态（是否可以点击）。最后给出了一个练习，和整个xml、java代码。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/494250
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号