How to Use Buttons in Java Applications
Developer.com content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.
A button is a Swing component in Java that is usually used to register some action from a user. The action comes in the form of a button being clicked. To use a button in an application or as part of a graphical user interface (GUI), developers need to create an instance of the JButton class. JButton is a class that inherits from JComponent. Therefore, you can apply the JComponent features, such as layout and key bindings, on your buttons.
In this tutorial, programmers will learn how to work with buttons in Java.
Before we begin, have you ever considered taking an online course to learn Java software development? We have a great list of the Top Online Courses to Learn Java to help get you started.
How to Use the JButton Class in Java
To create a button, simply instantiate the JButton class in your Java code like so:
JButton button = new JButton("Button"); Programmers can supply a string (or icon) to the constructor of JButton as an identifier on the screen. Since JButton is a JComponent, you need to add it to a top level container, such as JFrame, JDialog, or JApplet in order for it to appear on screen.
The Java code example below uses the JFrame container:
import javax.swing.*; class SimpleButton < public static void main(String args[])< JFrame frame = new JFrame(); JButton button = new JButton("Button"); frame.add(button); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(400,400); frame.setLocationRelativeTo(null); frame.setVisible(true); >> You should be able to see a button displayed on your screen when you run this code in your integrated development environment (IDE) or code editor:
It is important for developers to note that, when you run the code above, you may not get a similar display. This is because Swing components, by default, take on the look and feel of your application’s environment.
The example code shown does not achieve anything when you click or press the button. In practice, buttons are used to perform some action when a certain event on them occurs (i.e when pressed). This is referred to as listening for an event. The next section discusses how to listen for button events in Java.
How to Listen for Events on Buttons in Java
There are three steps programmers need to follow in order to listen for an event on a button. First, you need to implement the ActionListener interface on your event handling class. You could also extend a class that implements ActionListener instead. Here is how that looks in Java code:
class EventClass implements ActionListener < //some code here >
Second, you need to add an instance of the event handler as an action listener to one or more components using the addActionListener() method:
GuiComponent.addActionListener(EventClassInstance);
The final step is to provide an implementation of the actionPerformed(ActionEvent e) method, which performs some action whenever an event is registered on a component. This method is the only method in the ActionListener interface and it is always called when an action is performed.
Java Code Example for Button Click Events
The Java code example below displays the number of clicks a user has so far made when they click Button1:
import javax.swing.*; import java.awt.*; import java.awt.event.*; class ClicksCount implements ActionListener < int count = 0;// store number of clicks ClicksCount()< JFrame frame = new JFrame(); JButton button1 = new JButton("Button1"); JButton button2 = new JButton("Button2"); button1.addActionListener(this); frame.setLayout(new BoxLayout(frame.getContentPane(), BoxLayout.Y_AXIS)); frame.add(button1); frame.add(button2); frame.getRootPane().setDefaultButton(button1); // sets default button frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(450,450); frame.setLocationRelativeTo(null); frame.setVisible(true); >public void actionPerformed(ActionEvent e) < count++; System.out.println("You have clicked the ACTIVE button " + count + " times"); >public static void main(String args[]) < ClicksCount Clicks = new ClicksCount(); >> When you compile and run the code above, you should see two buttons. If you take good notice, you will observe that Button1 has been highlighted. This is because it has been set as the default button:
The default button is the button that initially appears to have the focus when the program is first run. When you press Enter on your keyboard, the program clicks this button since it was already selected by default. Pressing Tab will shift focus to the other button.
You can only have, at most, one default button, and you set it by calling the setDefaultButton() method on the root pane of a top-level container.
If you click Button2 in this example, you will notice that there is not a message displayed. This is because no event handler has been registered to listen for events on this button. In other words, you would have to use the addActionListener() method with Button2 to ensure that actionPerformed(ActionEvent e) is called when it is clicked.
Final Thoughts on Buttons and Events in Java
Since you are dealing with Swing components when using buttons and JButtons, remember to import the javax.swing library into your Java code. Also, in order to use an event listener, you need to add the java.awt library, as shown in the last code example. If you do not include these libraries, you will get a compilation error.
How to Write an Action Listener
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.
An action event occurs, whenever an action is performed by the user. Examples: When the user clicks a button, chooses a menu item, presses Enter in a text field. The result is that an actionPerformed message is sent to all action listeners that are registered on the relevant component.
To write an Action Listener, follow the steps given below:
- Declare an event handler class and specify that the class either implements an ActionListener interface or extends a class that implements an ActionListener interface. For example:
public class MyClass implements ActionListenersomeComponent.addActionListener(instanceOfMyClass);public void actionPerformed(ActionEvent e) < . //code that reacts to the action. >In general, to detect when the user clicks an onscreen button (or does the keyboard equivalent), a program must have an object that implements the ActionListener interface. The program must register this object as an action listener on the button (the event source), using the addActionListener method. When the user clicks the onscreen button, the button fires an action event. This results in the invocation of the action listener's actionPerformed method (the only method in the ActionListener interface). The single argument to the method is an ActionEvent object that gives information about the event and its source.
Let us write a simple program which displays how many number of times a button is clicked by the user. First, here is the code that sets up the TextField , button and numClicks variable:
public class AL extends Frame implements WindowListener,ActionListener < TextField text = new TextField(20); Button b; private int numClicks = 0;In the above example, the event handler class is AL which implements ActionListener.
We would like to handle the button-click event, so we add an action listener to the button b as below:
b = new Button("Click me"); b.addActionListener(this);In the above code, Button b is a component upon which an instance of event handler class AL is registered.
Now, we want to display the text as to how many number of times a user clicked button. We can do this by writing the code as below:
public void actionPerformed(ActionEvent e) < numClicks++; text.setText("Button Clicked " + numClicks + " times");Now, when the user clicks the Button b, the button fires an action event which invokes the action listener's actionPerformed method. Each time the user presses the button, numClicks variable is appended and the message is displayed in the text field.
Here is the complete program(AL.java):
import java.awt.*; import java.awt.event.*; public class AL extends Frame implements WindowListener,ActionListener < TextField text = new TextField(20); Button b; private int numClicks = 0; public static void main(String[] args) < AL myWindow = new AL("My first window"); myWindow.setSize(350,100); myWindow.setVisible(true); >public AL(String title) < super(title); setLayout(new FlowLayout()); addWindowListener(this); b = new Button("Click me"); add(b); add(text); b.addActionListener(this); >public void actionPerformed(ActionEvent e) < numClicks++; text.setText("Button Clicked " + numClicks + " times"); >public void windowClosing(WindowEvent e) < dispose(); System.exit(0); >public void windowOpened(WindowEvent e) <> public void windowActivated(WindowEvent e) <> public void windowIconified(WindowEvent e) <> public void windowDeiconified(WindowEvent e) <> public void windowDeactivated(WindowEvent e) <> public void windowClosed(WindowEvent e) <> >More Examples: Beeper program example is available in this trail's introduction to events, Introduction to Event Listeners. You can find the entire program in Beeper.java . The other example described in that section, MultiListener.java , has two action sources and two action listeners, with one listener listening to both sources and the other listening to just one.
The Action Listener API
Because ActionListener has only one method, it has no corresponding adapter class.
| Method | Purpose |
|---|---|
| actionPerformed(actionEvent) | Called just after the user performs an action. |
actionEvent.getModifiers() & ActionEvent.SHIFT_MASK
Examples that Use Action Listeners
The following table lists some of the many examples that use action listeners.
| Example | Where Described | Notes |
|---|---|---|
| Beeper | This section and Introduction to Event Listeners | Contains one button with one action listener that beeps when you click the button. |
| MultiListener | Introduction to Event Listeners | Registers two different action listeners on one button. Also registers the same action listener on two different buttons. |
| RadioButtonDemo | How to Use Radio Buttons | Registers the same action listener on five radio buttons. The listener uses the getActionCommand method to determine which radio button fired the event. |
| MenuDemo | How to Use Menus | Shows how to listen for action events on menu items. |
| TextDemo | How to Use Text Fields | An applet that registers an action listener on a text field. |
| IconDemo | How to Use Icons | Loads an image in an action listener. Because loading an image can take a while, this program uses a SwingWorker to load the image in a background thread. |
| TableDialogEditDemo | How to Use Tables | Registers an action listener through a factory method on the OK button of a color chooser dialog. |
| SliderDemo | How to Use Sliders | Registers an action listener on a timer that controls an animation loop. |
Previous page: Implementing Listeners for Commonly Handled Events
Next page: How to Write a Caret Listener