Как сделать кнопку в java
Одним из часто используемых элементов являются кнопки, которые представлены классом android.widget.Button . Ключевой особенностью кнопок является возможность взаимодействия с пользователем через нажатия.
Некоторые ключевые атрибуты, которые можно задать у кнопок:
- text : задает текст на кнопке
- textColor : задает цвет текста на кнопке
- background : задает фоновый цвет кнопки
- textAllCaps : при значении true устанавливает текст в верхнем регистре. По умолчанию как раз и применяется значение true
- onClick : задает обработчик нажатия кнопки
Итак, изменим код в activity_main.xml следующим образом:
При помощью атрибута android:onClick можно задать метод в коде java, который будет обрабатывать нажатия кнопки. Так, в вышеприведенном примере это метод sendMessage . Теперь перейдем к коду MainActivity и пропишем в нем такой метод:
package com.example.viewapp; import androidx.appcompat.app.AppCompatActivity; import android.os.Bundle; import android.view.View; import android.widget.EditText; import android.widget.TextView; public class MainActivity extends AppCompatActivity < @Override protected void onCreate(Bundle savedInstanceState) < super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); >// Обработка нажатия кнопки public void sendMessage(View view) < TextView textView = findViewById(R.id.textView); EditText editText = findViewById(R.id.editText); textView.setText("Добро пожаловать, " + editText.getText()); >>
При создании метода обработки нажатия следует учитывать следующие моменты:
- Метод должен объявляться с модификатором public
- Должен возвращать значение void
- В качестве параметра принимать объект View . Этот объект View и представляет собой нажатую кнопку
В данном случае после нажатия на кнопку в TextView выводится текст из EditText.
Аналогичный пример полностью в коде MainActivity:
package com.example.viewapp; import androidx.appcompat.app.AppCompatActivity; import androidx.constraintlayout.widget.ConstraintLayout; import android.os.Bundle; import android.view.View; import android.widget.Button; import android.widget.EditText; import android.widget.TextView; public class MainActivity extends AppCompatActivity < EditText editText; TextView textView; @Override protected void onCreate(Bundle savedInstanceState) < super.onCreate(savedInstanceState); //setContentView(R.layout.activity_main); ConstraintLayout constraintLayout = new ConstraintLayout(this); textView = new TextView(this); textView.setId(View.generateViewId()); ConstraintLayout.LayoutParams textViewLayout = new ConstraintLayout.LayoutParams( ConstraintLayout.LayoutParams.MATCH_CONSTRAINT, ConstraintLayout.LayoutParams.WRAP_CONTENT ); textViewLayout.topToTop = ConstraintLayout.LayoutParams.PARENT_ID; textViewLayout.leftToLeft = ConstraintLayout.LayoutParams.PARENT_ID; textViewLayout.rightToRight = ConstraintLayout.LayoutParams.PARENT_ID; textView.setLayoutParams(textViewLayout); constraintLayout.addView(textView); editText = new EditText(this); editText.setId(View.generateViewId()); editText.setHint("Введите имя"); ConstraintLayout.LayoutParams editTextLayout = new ConstraintLayout.LayoutParams( ConstraintLayout.LayoutParams.MATCH_CONSTRAINT, ConstraintLayout.LayoutParams.WRAP_CONTENT ); editTextLayout.topToBottom = textView.getId(); editTextLayout.leftToLeft = ConstraintLayout.LayoutParams.PARENT_ID; editTextLayout.rightToRight = ConstraintLayout.LayoutParams.PARENT_ID; editText.setLayoutParams(editTextLayout); constraintLayout.addView(editText); Button button = new Button(this); button.setText("Ввод"); ConstraintLayout.LayoutParams buttonLayout = new ConstraintLayout.LayoutParams( ConstraintLayout.LayoutParams.WRAP_CONTENT, ConstraintLayout.LayoutParams.WRAP_CONTENT ); buttonLayout.topToBottom = editText.getId(); buttonLayout.leftToLeft = ConstraintLayout.LayoutParams.PARENT_ID; button.setLayoutParams(buttonLayout); constraintLayout.addView(button); button.setOnClickListener(new View.OnClickListener() < public void onClick(View v) < // Обработка нажатия textView.setText("Добро пожаловать, " + editText.getText()); >>); setContentView(constraintLayout); > >
При программном создании кнопки мы можем определить у нее слушатель нажатия View.OnClickListener и с помощью его метода onClick также обработать нажатие:
button.setOnClickListener(new View.OnClickListener() < public void onClick(View v) < // Обработка нажатия >>);
Button в Java Swing. Как выполнить действие после нажатия кнопки
Создал кнопку в диалоговом окне в Java через Swing. Теперь нужно чтобы при нажатии на эту кнопку выходило окно с сообщением. Где-то видел, что можно сделать через if(если кнопка нажата) то <>. Хотел бы узнать, какой именно синтаксис должен быть в скобках оператора if.
Button b = new Button("Button"); JOptionPane.showMessageDialog(null, b); if(b.isSelected())
Отслеживать
задан 29 июн 2019 в 13:39
Artur Vartanyan Artur Vartanyan
1,166 5 5 золотых знаков 17 17 серебряных знаков 40 40 бронзовых знаков
1 ответ 1
Сортировка: Сброс на вариант по умолчанию
Таких примеров на самом деле уйму в интернете, но окей. Вот пример создания слушателя
button.addActionListener(new ActionListener() < public void actionPerformed(ActionEvent e) < System.out.println("OK"); >>); При нажатии на кнопку button — в консоли пропишется ОК
P.S. Насколько я помню Button относится к библиотеке AWT , если вы хотите писать именно на Swing , рекомендую использовать JButton , и почему именно Swing ? Новые программы сейчас на этой библиотеке не пишут, только поддерживаются старые, и то уже не часто встретишь их на сколько я знаю, попробуйте изучить хотя бы JavaFX
Button (Кнопка)
Кнопка — один из самых распространенных элементов управления в программировании. Наследуется от TextView и является базовым классом для класса СompoundButton. От класса CompoundButton в свою очередь наследуются такие элементы как CheckBox, ToggleButton и RadioButton. В Android для кнопки используется класс android.widget.Button. На кнопке располагается текст и на кнопку нужно нажать, чтобы получить результат. Альтернативой ей может служить компонент ImageButton (android.widget.ImageButton), у которого вместо текста используется изображение.
В студии кнопка представлена компонентом Button в разделе Widgets. Управлять размером шрифта, цветом текста и другими свойствами можно через атрибут textAppearance, который задействует системные стили. Выпадающий список данного свойства содержит огромный перечень вариантов. Также вы можете вручную задать конкретные индивидуальные настройки через отдельные свойства.
Если вы растягиваете кнопку по всей ширине экрана (android:layout_width=»match_parent»), то дополнительно рекомендую использовать атрибут android:layout_margin (или родственные ему layout_marginRight и layout_marginLeft) для создания отступов от краев экрана (веб-мастера знакомы с этими терминами).
Так как кнопка является наследником TextView, то использует многие знакомые атрибуты: textColor, textSize и др.
Три способа обработки событий нажатий на кнопку
Если вы разместили на экране кнопку и будете нажимать на неё, то ничего не произойдёт. Необходимо написать код, который будет выполняться при нажатии. Существует несколько способов обработки нажатий на кнопку.
Первый способ — атрибут onClick
Относительно новый способ, специально разработанный для Android — использовать атрибут onClick (на панели свойств отображается как On Click):
android:onClick="onMyButtonClick"
Имя для события можно выбрать произвольное, но лучше не выпендриваться. Далее нужно прописать в классе активности придуманное вами имя метода, который будет обрабатывать нажатие. Метод должен быть открытым (public) и с одним параметром, использующим объект View. Вам нужно выучить пять слов для создания метода, а сам метод поместить в класс (если вы ещё путаетесь в структуре Java-кода, то вставьте метод перед последней фигурной скобкой):
public void onMyButtonClick(View view) < // выводим сообщение Toast.makeText(this, "Зачем вы нажали?", Toast.LENGTH_SHORT).show(); >
Когда пользователь нажимает на кнопку, то вызывается метод onMyButtonClick(), который в свою очередь генерирует всплывающее сообщение.
Обратите внимание, что при подобном подходе вам не придётся даже объявлять кнопку через конструкцию (Button)findViewById(R.id.button1), так как Android сама поймёт, что к чему. Данный способ применим не только к кнопке, но и к другим элементам и позволяет сократить количество строк кода.
Данный способ не будет работать в фрагментах. Кнопка должна быть частью активности, а не фрагмента.
Второй способ — метод setOnClickListener()
Более традиционный способ в Java — через метод setOnClickListener(), который прослушивает нажатия на кнопку. Так как для начинающего программиста код может показаться сложным, то рекомендуется использовать подсказки студии. Вот как это будет выглядеть. Предположим, у вас на экране уже есть кнопка button. В коде вы объявляете её обычным способом:
Button button = (Button) findViewById(R.id.button);
Следующий шаг — написание метода для нажатия. Напечатайте имя элемента и поставьте точку button. — среда разработки покажет вам список доступных выражений для продолжения кода. Вы можете вручную просмотреть и выбрать нужный вариант, а можно продолжать набирать символы, чтобы ускорить процесс. Так как с нажатиями кнопок вам часто придётся работать, то запомните название его метода (хотя бы первые несколько символов) — набрав четыре символа (seto), вы увидите один оставшийся вариант, дальше можно сразу нажать клавишу Enter, не набирая оставшиеся символы. У вас появится строка такого вида:
button.setOnClickListener()
Курсор будет находиться внутри скобок и появится подсказка OnClickListener l. Начинайте набирать new OnClickListener. Здесь также не обязательно набирать имя полностью. Набрав слово Oncl, вы увидете нужный вариант и снова нажимайте Enter. В результате вы получите готовую заготовку для обработки нажатия кнопки:
button.setOnClickListener(new View.OnClickListener() < @Override public void onClick(View v) < >>);
Теперь у вас есть рабочая заготовка и сразу внутри фигурных скобок метода onClick() вы можете писать свой код. Рекомендую потренироваться и набить руку в создании заготовки. Это не так сложно, и с практикой навык закрепится автоматически.
Как вариант, можно вынести код для OnClickListener в отдельное место, это удобно, когда кнопок на экране несколько и такой подход позволит упорядочить код. Удалите предыдущий пример и начните писать код заново. Принцип такой же, немного меняется порядок. В предыдущем примере мы сразу прописали в методе setOnClickListener слушателя new OnClickListener. с методом onClick(). Можно сначала отдельно объявить отдельную переменную myButtonClickListener:
OnClickListener myButtonClickListener = new OnClickListener() < @Override public void onClick(View v) < >>;
Во время набора активно используйте подсказки через Ctrl+Space. Набрали несколько символов у первого слова и нажимайте эту комбинацию, набрали после слова new несколько символов и снова нажимайте указанную комбинацию — заготовка будет создана за несколько секунд, а вы избежите возможных опечаток.
У нас есть готовая переменная, и теперь, когда вы будете набирать код button.setOnClickListener, то вместо new OnClickListener впишите готовую переменную.
Для новичка описание может показаться сумбурным и не понятным, но лучше самостоятельно проделать эти операции и понять механизм.
Третий способ — интерфейс OnClickListener
Третий способ является родственным второму способу и также является традиционным для Java. Кнопка присваивает себе обработчика с помощью метода setOnClickListener (View.OnClickListener l), т.е. подойдет любой объект с интерфейсом View.OnClickListener. Мы можем указать, что наш класс Activity будет использовать интерфейс View.OnClickListener.
Опять стираем код от предыдущего примера. Далее после слов extends Activity дописываем слова implements OnClickListener. При появлении подсказки не ошибитесь. Обычно первым идёт интерфейс для диалогов, а вторым нужный нам View.OnClickListener.
Название вашего класса будет подчёркнуто волнистой красной чертой, щёлкните слово public и дождитесь появления красной лампочки, выберите вариант Implement methods. Появится диалоговое окно с выделенным методом onClick. Выбираем его и в коде появится заготовка для нажатия кнопки.
@Override public void onClick(View v)
Метод будет реализован не в отдельном объекте-обработчике, а в Activity, который и будет выступать обработчиком. В методе onCreate() присвоим обработчик кнопке. Это будет объект this, т.е. текущий объект нашей активности.
button.setOnClickListener(this);
На первых порах такой способ также покажется вам сложным и непонятным. Со временем и опытом понимание обязательно придёт.
Лично я рекомендую вам использовать первый способ, как самый простой и понятный. Использование второго и третьего способа дадут вам представление, как писать обработчики для других событий, так как кнопка может иметь и другие события. Например, кроме обычного нажатия существует долгое нажатие на кнопку (long click). Один из таких примеров с методом касания я привёл в конце этой статьи.
О том, как обрабатывать щелчки кнопки я написал отдельную статью Щелчок кнопки/Счетчик ворон. Также кнопки часто будут встречаться во многих примерах на сайте. Про обработку длительный нажатий можно прочитать в статье, посвященной ImageButton.
Плодитесь и размножайтесь — это про кошек, а не про кнопки
Когда у вас одна кнопка в окне, то у вас будет один метод, две кнопки — два метода и так далее. Если у вас несколько кнопок, то не обязательно для каждой прописывать свой метод, можно обойтись и одним, а уже в самом методе разделять код по идентификатору кнопки. Если вы посмотрите на код в предыдущих примерах, то увидите, что в методе присутствует параметр View, который и позволяет определить, для какой кнопки предназначен кусок кода:
public void onMyButtonClick(View view) < switch(view.getId()) < case R.id.button1: // идентификатор "@+id/button1" showAlertDialog(); break; . >
Предположим, у вас есть три кнопки:
import android.view.View.OnClickListener; public class ButtonDemoActivity extends Activity implements OnClickListener. final Button button1 = (Button)findViewById(R.id.button1); final Button button2 = (Button)findViewById(R.id.button2); final Button button3 = (Button)findViewById(R.id.button3); // устанавливаем один обработчик для всех кнопок button1.setOnClickListener(this); button2.setOnClickListener(this); button3.setOnClickListener(this); // анализируем, какая кнопка была нажата. Всего один метод для всех кнопок @Override public void onClick(View v) < switch (v.getId()) < case R.id.button1: editText.setText("Нажата кнопка Button1"); break; case R.id.button2: editText.setText("Нажата кнопка Button2"); break; case R.id.button3: editText.setText("Нажата кнопка Button3"); break; >>
Как видите, мы сократили количество кода. Теперь у нас один обработчик onClick(), в котором прописаны действия для трёх кнопок.
Сделать кнопку недоступной
Иногда нужно сделать кнопку недоступной и активировать её при определённых условиях. Через XML нельзя сделать кнопку недоступной (нет подходящего атрибута). Это можно сделать программно через метод setEnabled():
button.setEnabled(false);
Как альтернативу можете рассмотреть атрибут android:clickable, который позволит кнопке не реагировать на касания, но при этом вид кнопки останется обычным.
Сделать кнопку плоской
Стандартная кнопка на экране выглядит выпуклой. Но в некоторых случаях желательно использовать плоский интерфейс. Раньше для этих целей можно было использовать TextView с обработкой щелчка. Но теперь рекомендуют использовать специальный стиль borderlessButtonStyle:
Кнопка сохранит своё привычное поведение, будет менять свой цвет при нажатии и т.д.
С появлением Material Design добавились другие стили, например, style=»@style/Widget.AppCompat.Button.Borderless», который является предпочтительным вариантом. Попробуйте также style=»@style/Widget.AppCompat.Button.Borderless.Colored»
Коснись меня нежно
Если вы внимательно понаблюдаете за поведением кнопки, то увидите, что код срабатывает в тот момент, когда вы отпускаете свою лапу, извините, палец с кнопки. Для обычных приложений это вполне нормально, а для игр на скорость такой подход может оказаться слишком медленным. В подобных случаях лучше обрабатывать ситуацию не с нажатием кнопки, а с его касанием. В Android есть соответствующий слушатель OnTouchListener():
Button button = (Button) findViewById(R.id.button); button.setOnTouchListener(new OnTouchListener() < @Override public boolean onTouch(View v, MotionEvent event) < if (event.getAction() == MotionEvent.ACTION_DOWN) < Toast.makeText(getApplicationContext(), "Молодой человек, не прикасайтесь ко мне!", Toast.LENGTH_SHORT).show(); >return false; > >);
У метода onTouch() есть параметр MotionEvent, позволяющий более тонко определять касания экрана. Если произойдет событие, когда пользователь коснулся экрана, то ему будет соответствовать константа ACTION_DOWN. Соответственно, если пользователь уберёт палец, то нужно использовать константу ACTION_UP. Таким образом, можете расценивать щелчок кнопки как комбинацию двух событий — касания и отпускания.
К сожалению, на сегодняшний день в Android нет метода Погладить. Коты недовольны.
Получить текст с кнопки
Навеяно вопросом с форума. Задача — получить текст кнопки в методе onClick(). У метода есть параметр типа View, у которого нет метода getText(). Для этого нужно привести тип к типу Button.
public void onClick(View view)
Если у вас несколько кнопок привязаны к методу onClick(), то щелчок покажет текст нажатой кнопки.
Дополнительное чтение
SwipeButton — кнопка с поддержкой свайпа
JButton, JGroupButton, Action
Библиотека Swing включает абсолютно все придуманные на сегодняшний день элементы управления. К ним относятся кнопки, флажки, переключатели, меню и его элементы, и многое другое. Все эти элементы в библиотеке связаны, поскольку они унаследованы от абстрактного класса AbstractButton, определяющего поведение любого компонента, претендующего на звание элемента управления.
Кнопки JButton
Кнопки JButton кроме собственного внешнего вида не включают практически ничего уникального. Поэтому всё, что верно для кнопок, будет верно и для остальных элементов управления. Пример кода создания обычной кнопки :
JButton button = new JButton("Кнопка"): button.addActionListener(new ButtonAction());
Основное время работы с кнопками связано не столько с их созданием и настройкой, сколько с размещением в контейнере и написанием обработчиков событий.
Интерфейс кнопок
Внешний вид кнопок JButton можно легко изменить, не меняя менеджера внешнего вида и поведения. С интерфейсом кнопок можно делать практически все — сопоставлять каждому действию пользователя своё изображение, убирать рамку, закрашивать в любой цвет, перемещать содержимое по разным углам, не рисовать фокус.
Рассмотрим пример, в котором будут созданы кнопки JButton разных форм и размеров.
// Класс представления различного внешнего вида кнопок JButton import java.awt.*; import java.awt.event.ItemEvent; import java.awt.event.ActionEvent; import java.awt.event.ItemListener; import java.awt.event.ActionListener; import javax.swing.*; import javax.swing.event.ChangeEvent; import javax.swing.event.ChangeListener; public class ButtonStylesTest extends JFrame < private static final long serialVersionUID = 1L; public ButtonStylesTest() < super("Интерфейсы кнопок"); setDefaultCloseOperation( EXIT_ON_CLOSE ); // Устанавливаем последовательное расположение Container container = getContentPane(); container.setLayout(new FlowLayout( FlowLayout.LEFT, 10, 10)); // Простая кнопка JButton button = new JButton("Обычная кнопка"); // Подключение слушателей событий button.addActionListener(new ListenerAction()); button.addChangeListener(new ListenerChange()); // присоединение слушателя прямо на месте button.addItemListener(new ItemListener() < public void itemStateChanged(ItemEvent e) < System.out.println("Это событие мы не увидим"); >>); container.add(button); // Кнопка со значками на все случаи жизни button = new JButton(); button.setIcon (new ImageIcon("images/copy.png")); button.setRolloverIcon(new ImageIcon("images/cut.png" )); button.setPressedIcon (new ImageIcon("images/open.png")); button.setDisabledIcon(new ImageIcon("images/save.png")); // Убираем все ненужные рамки и закраску button.setBorderPainted(false); button.setFocusPainted(false); button.setContentAreaFilled(false); container.add(button); // Кнопка с описанием интерфейса в виде HTML-текста button = new JButton("Синяя кнопка"); // button.setOpaque(true); button.setBackground(Color.blue); container.add(button); // Изменение выравнивания текста и изображения button = new JButton("Изменение выравнивания", new ImageIcon("images/exit.png")); button.setMargin (new Insets(10, 10, 10, 10)); button.setVerticalAlignment (SwingConstants.TOP ); button.setHorizontalAlignment (SwingConstants.RIGHT ); button.setHorizontalTextPosition(SwingConstants.LEFT ); button.setVerticalTextPosition (SwingConstants.BOTTOM); button.setIconTextGap(10); // сделаем кнопку большой, чтобы увидеть выравнивание button.setPreferredSize(new Dimension(300, 100)); container.add(button); // отключенная кнопка button = new JButton("Выключено"); button.setEnabled(false); container.add(button); // выводим окно на экран setSize(400, 350); setVisible(true); > class ListenerAction implements ActionListener < public void actionPerformed(ActionEvent e) < System.out.println("Нажатие кнопки! От - "+ e.getActionCommand() + "\n"); >> class ListenerChange implements ChangeListener < public void stateChanged(ChangeEvent e) < // Источник события Object src = e.getSource(); System.out.println("Cообщение о смене состояния объекта : " + src.getClass()); >> public static void main(String[] args) < new ButtonStylesTest(); >>
В примере создается небольшое окно с менеджером последовательного расположения FlowLayout. В форме помещается несколько кнопок, для каждой из которых используется свой способ представления внешнего вида. На скриншоте представлен интерфейс окна.
Первой в контейнер помещается самая обычная кнопка. Затем следует кнопка, на которой вместо текста располагаются иконки на «все случаи жизни». Для определения иконок применяются свойства, перечисленные в таблице.
| Свойства | Описание |
|---|---|
| icon | Установка «обычной» иконки. |
| rolloverlcon | Получение эффекта «наведения мыши». Когда указатель мыши оказывается на кнопке, появляется эта иконка. Обычно в этом случае используется та же иконка, только к ней добавляется эффект объема или изменяется цвет части иконки. |
| pressedlcon | Представление иконки, которая отображается при нажатии на кнопке. Иконка остается до тех пор, пока кнопка мыши не отпущена. |
| disabledlcon | Если вы задаете иконку посредством данного свойства, то, когда кнопка будет отключена (метод setEnabled(false)), появится специальная иконка. Если специальной иконки нет, а обычная иконка есть, то в качестве иконки для отключенной кнопки будет использована черно-белая копия обычной иконки. |
Если вывести кнопку с иконками на экран «как есть», она будет выглядеть не очень хорошо, поскольку у нее останутся все свойственные обычной кнопке с текстом свойства — будет рисоваться рамка, при наличии фокуса появится контур, а при нажатии она будет закрашиваться темным цветом. Чтобы убрать эти эффекты, в примере и задействуются методы setBorderPainted(), setFocusPainted() и setContentAreaFilled().
Метод setBorderPainted() позволяет отключить прорисовку рамки. То же самое можно сделать вызовом setBorder(null), но в этом случае нельзя вернуть кнопке ее рамку обратно. Метод setFocusPainted() отключает прорисовку специального контура, проявляющегося, если кнопка обладает фокусом ввода. setContentAreaFilled() дает возможность отключить закраску кнопки в нажатом состоянии. С этими методами лучше быть осторожней, потому что пользователю с такой кнопкой работать гораздо сложнее: будет непонятно, выбрана кнопка или нет, где она начинается и т. п. Применять эти методы лучше только в тех приложениях, в которых весь интерфейс основан на разнообразных изображениях (например, в играх).
Методом setBackground() можно устанавливать цвет заполнения JButton. Цвет заполнения изменится только в том случае, если у кнопки включено свойство непрозрачности (opaque). По умолчанию оно установлено.
Кнопки JButton также, как и надписи JLabel, позволяют определять интерфейс с использованием HTML, что вместе с широчайшими возможностями по настройке расположения содержимого и по управлению всеми аспектами внешнего вида кнопок дает неограниченную власть над видом приложения.
Настройки кнопок JButton
В таблице представлены параметры, позволяющие выполнить определенные настройки интерфейса кнопок JButton.
| Свойства | Описание |
|---|---|
| margin | Управление размером полей, которые отделяют содержимое кнопки (текст и иконку) от ее границ. |
| verticalAlignment, horizontalAlignment |
Вертикальное и горизонтальное выравнивание всего содержимого кнопки (и значка, и текста) относительно границ кнопки. С их помощью это содержимое можно поместить в любой угол кнопки или в ее центр (по умолчанию оно там и находится). |
| horizontalTextPosition, verticalTextPosition |
Управление по горизонтали и вертикали положением текста кнопки относительно ее иконки, если она есть, конечно. |
| iconTextGap | Свойство позволяет изменить расстояние между иконкой и текстом. |
События элементов управления — ActionEvent, ChangeEvent, ItemEvent
Унаследованные от класса AbstractButton элементы управления, в том числе и кнопки JButton, могут посылать сообщения о трех типах событий (за исключением стандартных событий, общих для всех компонентов Swing). В таблице представлены эти события.
| Событие | Описание |
|---|---|
| ActionEvent слушатель ActionListener |
Событие при нажатии и отпускании кнопки. |
| ChangeEvent слушатель ChangeListener |
С помощью данного события модель кнопок ButtonModel взаимодействует со своим UI-представителем. Модель при изменении хранящегося в ней состояния кнопки (это может быть смена включенного состояния на выключенное, обычного на нажатое и т. п.) запускает событие ChangeEvent. UI-представитель обрабатывает это событие и соответствующим образом перерисовывает кнопку. |
| ItemEvent слушатель ItemListener |
Событие о смене состояния возникает в компонентах, которые имеют несколько равноценных состояний (например, флажки и переключатели). |
В примере после создания первой кнопки к ней подключаются слушатели событий. Для событий ActionEvent и ChangeEvent слушатели помещаются в отдельные внутренние классы, а слушатель события ItemEvent создается прямо на месте, как анонимный внутренний класс. При возникновении события информация об инициаторе выводится в консоль приложения. При щелчке на кнопке слушатель события определяет имя нажатой кнопки, используя метод getActionCommand() класса ActionEvent. Этот метод применяется для того, чтобы при обработке событий от нескольких кнопок в одном слушателе можно было их отличить. Событие ItemEvent не возникает вовсе, поскольку оно «работает» только с флажками, переключателями и другими компонентами, имеющими состояние, а кнопки его просто игнорируют.
Пример использования Action при создании JButton
// Использование Action при создании кнопки import java.awt.*; import java.awt.event.*; import javax.swing.*; public class AbstractActionTest extends JFrame < private static final long serialVersionUID = 1L; private final String BUTTON_NAME = "button1"; public AbstractActionTest() < super("Пример использования Action"); setDefaultCloseOperation(EXIT_ON_CLOSE); // Панель содержимого Container container = getContentPane(); // Устанавливаем менеджер последовательного расположения container.setLayout(new FlowLayout()); // Создание кнопок, выполняющих одно действие Action action = new SimpleAction(); JButton button1 = new JButton(action); button1.setName(BUTTON_NAME); button1.setText("First button"); button1.setMnemonic('F'); JButton button2 = new JButton(action); button2.setName("button2"); button2.setText("Second button"); button2.setMnemonic('S'); container.add(button1); container.add(button2); // выводим окно на экран setSize(320, 100); setVisible(true); >// Внутренний класс class SimpleAction extends AbstractAction < private static final long serialVersionUID = 1L; SimpleAction() < // Параметры команды // putValue(NAME, "Класс Action!"); putValue(SHORT_DESCRIPTION, "Это подсказка"); // putValue(MNEMONIC_KEY, new Integer('A')); >// Обработка события нажатия на кнопку public void actionPerformed(ActionEvent e) < JButton btn = (JButton) e.getSource(); System.out.println("Нажатие на кнопку "); // можно выключить команду, не зная, к каким компонентам она присоединена if (btn.getName().equalsIgnoreCase(BUTTON_NAME)) < btn.setEnabled(false); // Изменение надписи // putValue(NAME, "Disabled button"); btn.setText("Disabled button"); >> >; public static void main(String[] args) < new AbstractActionTest(); >>
В примере создаются две кнопки, которые выполняют одно и то же действие, и, соответственно, обладают одним и тем же набором параметров. Чтобы не дублировать код для настройки этих кнопок, создается один экземпляр команды SimpleAction, который и передается кнопкам.
SimpleAction расширяет абстрактный класс AbstractAction, имеющий поддержку слушателей PropertyChangeListener, которые оповещаются об изменениях в параметрах команды. Кнопки выступают в роли таких слушателей, что и позволяет им быть в курсе всех изменений и вовремя отображать их на экране. Все сводится к настройке параметров команды (обычно это производится в конструкторе) и определению метода actionPerformed(), отвечающего за обработку событий.
Параметры команды хранятся в виде пар «ключ-значение», где ключ — одна из строк, определенных в интерфейсе Action. Эта строка показывает, какой именно параметр команды хранится в паре. Для того чтобы изменить параметр, используется метод putValue().
Параметры интерфейса Action
- NAME
Определение надписи, которая будет выведена на кнопке или в меню; - SHORT_DESCRIPTION
Определение всплывающей подсказки; - MNEMONIC_KEY
Определение мнемоники;
Конечно, это не полный список ключей. Можно установить и несколько других параметров, в том числе иконку. Полный список можно найти в интерактивной документации Java.
Интерфейс примера представлен на следующих двух скриншотах.
В методе actionPerformed() определяется источник, вызвавший событие кнопки JButton. Если это кнопкам button1, то меняется ее наименование и она блокируется (скриншот справа).
Мнемоники
Разработчики Swing наделили библиотеку поддержкой мнемоник для всех элементов управления. Мнемоники позволяют получить доступ к компоненту нажатием специальной клавиши (обычно Alt) вместе с клавишей символа, идентифицирующего этот компонент.
Для обеспечения доступа пользователя к визуальному компоненту с помощью клавиатуры следует использовать следующие методы класса AbstractButton :
- setMnemonic(). Определение мнемоники, то есть определение клавиши символа в сочетании с управляющей клавишей (Alt) будет вызывать нажатие кнопки. Можно просто указать символ (в одинарных кавычках, регистр не учитывается), а можно использовать константы из класса Java.awt.event.KeyEvent.
- setDisplayedMnemonicIndex(). Этот метод появился в выпуске JDK 1.4 после жалоб разработчиков на невозможность управлять тем, какой из символов надписи кнопки будет подчеркиваться, то есть символизировать наличие мнемоники , если в надписи есть несколько одинаковых символов.
Пример определения мнемоники кнопки JButton :
JButton button = new JButton("Файл (F)"); button.setMnemonic('F');
Элементы управления JToggleButton, ButtonGroup, JRadioButton, JCheckBox
В приложениях, кроме кнопок, используются другие элементы управления, для которых характерно наличие двух устойчивых состояний. К ним относятся флажки, переключатели и выключатели. Единственное отличие их от JButton состоит в том, что они могут находиться в одном из двух состояний. При смене состояния эти компоненты генерируют событие ItemEvent, которое кнопки игнорируют.
Поддержка двух состояний встроена в класс выключателя JToggleButton, от которого, в свою очередь, унаследованы классы флажков и переключателей.
Выключатель JToggleButton
JToggleButton — довольно необычный элемент управления, чаще всего используемый в панелях инструментов, где он играет роль флажков. Фактически, по виду это та же самая кнопка, только ее можно нажать, и она остается в этом состоянии. Можно использовать JToggleButton и в обычном интерфейсе, когда нужно сделать выбор из двух альтернатив.
Группы элементов управления ButtonGroup
Класс ButtonGroup позволяет связать несколько элементов управления в логическую группу, в которой выбранным может быть только один из них. При выборе пользователем другого элемента управления класс ButtonGroup позаботится о том, чтобы выбранный прежде элемент вернулся в исходное состояние.
Переключатели JRadioButton
Переключатель JRadioButton унаследован от выключателя JToggleButton и отличается от него только внешним видом. JRadioButton используют, как правило, при объединении нескольких переключателей в группу и реализации выбора «один из многих». По одиночке в интерфейсе их практически не используют; обычно эту роль исполняют флажки.
Флажки JCheckBox
Флажки в библиотеке Swing реализуются классом JCheckBox. Они, также как и переключатели, отличаются от выключателей только внешним видом. Флажки используются там, где нужно предоставить пользователю возможность что-то включить или выключить. Они также могут группироваться. Но, в отличие от JRadioButton, никогда не реализуют выбор «один из нескольких», а всегда позволяют выбрать несколько равноценных вариантов.
Рассмотрим пример, который включает все перечисленные элементы управления.
// Кнопки управления import java.awt.*; import java.awt.event.*; import javax.swing.*; public class ButtonsTest extends JFrame < private static final long serialVersionUID = 1L; private JToggleButton button; private JPanel panelRadio, panelCheck; public ButtonsTest() < super("Кнопки управления"); setDefaultCloseOperation( EXIT_ON_CLOSE ); // Панель содержимого Container container = getContentPane(); // Последовательное расположение container.setLayout(new FlowLayout()); // Создание кнопки JToggleButton button = new JToggleButton("Нажмите", false); // Слушатель события о смене состояния button.addItemListener(new ItemListener() < public void itemStateChanged(ItemEvent e) < String text = (button.isSelected()) ? "Отпустите" : "Нажмите"; button.setText(text); panelRadio.setVisible(!button.isSelected()); panelCheck.setVisible( button.isSelected()); >>); // Группа связанных радио-переключателей panelRadio = new JPanel(new GridLayout(0, 1, 0, 5)); panelRadio.setBorder(BorderFactory.createTitledBorder("Напитки")); String[] names1 = < "Байкал", "Тархун", "Минеральная" >; ButtonGroup bg1 = new ButtonGroup(); for (int i = 0; i < names1.length; i++) < JRadioButton radio = new JRadioButton(names1[i]); panelRadio.add(radio); bg1.add(radio); >// Группа связанных флажков panelCheck = new JPanel(new GridLayout(0, 1, 0, 5)); panelCheck.setBorder(BorderFactory.createTitledBorder("Мороженое")); String[] names2 = < "Шоколадное", "Крем-брюле", "Пломбир" >; ButtonGroup bg2 = new ButtonGroup(); for (int i = 0; i < names2.length; i++) < JCheckBox check = new JCheckBox(names2[i]); panelCheck.add(check); bg2.add(check); >panelCheck.setVisible(false); // Добавляем компоненты в контейнер container.add(button1 ); container.add(panelRadio); container.add(panelCheck); // Открываем окно setSize(280, 170); setVisible(true); > //-------------------------------------- public static void main(String[] args) < new ButtonsTest(); >>
Интерфейс приложения представлен на следующих двух скриншотах. На левом скриншоте кнопка JToggleButton отпущена, панель panelRadio «открыта», в панели размещены кнопки JRadioButton. Панель panelCheck «скрыта». На правом скриншоте кнопка JToggleButton нажата, панель panelRadio «скрыта», панель panelCheck «открыта», в панели размещены кнопки JCheckBox.
В примере обработка события «изменения состояния кнопки» JToggleButton выполняется в методе itemStateChanged слушателя ItemListener. В зависимости от состояния нажатия кнопки изменяется название кнопки и «окрывается/скрывается» одна из панелей.
Архив примеров
Исходные коды примеров, рассмотренных на странице, можно скачать здесь (4.28 Кб).