Start of Tutorial > Start of Trail > Start of Lesson

Search Feedback Form

A Quick Tour of a Swing Application's Code

This section takes you through the code for the SwingApplication program. The next lesson, Swing Features and Concepts, provides full explanations of the topics introduced in this section. It also provides a bigger, more realistic example that you can use to expand and test your Swing knowledge.

SwingApplication brings up a window that looks like this:

Each time the user clicks the button, the label is updated. You can find the whole program in SwingApplication.java.

The code in SwingApplication.java accomplishes the following tasks:

• Importing Swing packages
• Choosing the look and feel
• Setting up the top-level container
• Setting up buttons and labels
• Adding components to containers
• Adding borders around components
• Handling events
• Dealing with thread issues
• Supporting assistive technologies

Importing Swing Packages

The following line imports the main Swing package:

import javax.swing.*;

---

Note:  Early JFC 1.1 and Java 2 SDK v 1.2 beta releases used different names for the Swing packages. See Swing Package Names for details.

---

Most Swing programs also need to import the two main AWT packages:

import java.awt.*;
import java.awt.event.*;

Choosing the Look and Feel

Swing allows you to specify which look and feel your program uses -- Java look and feel, Windows look and feel, CDE/Motif look and feel, and so on. The bold code in the following snippet shows you how SwingApplication specifies the look and feel:

public static void main(String[] args) {
    try {
        UIManager.setLookAndFeel(
            UIManager.getCrossPlatformLookAndFeelClassName());
    } catch (Exception e) { }

    ...//Create and show the GUI...
}

The preceding code essentially says, "I don't care whether the user has chosen a look and feel -- use the cross-platform look and feel (the Java look and feel)." You already know what the Java look and feel looks like, since almost all of our screenshots show it.

For more information on specifying the look and feel, see How to Set the Look and Feel.

Setting Up the Top-Level Container

Every program that presents a Swing GUI contains at least one top-level Swing container. For most programs, the top-level Swing containers are instances of JFrame, JDialog, or (for applets) JApplet. Each JFrame object implements a single main window, and each JDialog implements a secondary window. Each JApplet object implements an applet's display area within a browser window. A top-level Swing container provides the support that Swing components need to perform their painting and event handling.

The SwingApplication example has only one top-level container, a JFrame. When the user closes the frame, the application exits. Here is the code that sets up and shows the frame:

public class SwingApplication {
    ...
    public static void main(String[] args) {
	...
        JFrame frame = new JFrame("SwingApplication");
        //...create the components to go into the frame...
        //...stick them in a container named contents...
        frame.getContentPane().add(contents, BorderLayout.CENTER);

        //Finish setting up the frame, and show it.
        frame.addWindowListener(...);
        frame.pack();
        frame.setVisible(true);
    }
}

For more information about top-level containers, see Swing Components and the Containment Hierarchy.

Setting Up Buttons and Labels

Like most GUIs, the SwingApplication GUI contains a button and a label. (Unlike most GUIs, that's about all that SwingApplication contains.) Here's the code that initializes the button:

JButton button = new JButton("I'm a Swing button!");
button.setMnemonic(KeyEvent.VK_I);
button.addActionListener(...create an action listener...);

The first line creates the button. The second sets the I key as the mnemonic that the user can use to simulate a click of the button. For example, in the Java look and feel, typing Alt-i results in a button click. The third line registers an event handler for the button click. You'll see the event-handling code for this program in Handling Events.

Here's the code that initializes and manipulates the label:

...//where instance variables are declared:
private static String labelPrefix = "Number of button clicks: ";
private int numClicks = 0;

...//in GUI initialization code:
final JLabel label = new JLabel(labelPrefix + "0    ");
...
label.setLabelFor(button);

...//in the event handler for button clicks:
label.setText(labelPrefix + numClicks);

The preceding code is pretty straightforward, except for the line that invokes the setLabelFor method. That code exists solely to hint to assistive technologies that the label describes the button. For more information, see Supporting Assistive Technologies.

For more information about Swing components such as buttons and labels, see Using Swing Components.

Adding Components to Containers

SwingApplication groups the label and button in a container (a JPanel) before adding the components to the frame. Here's the code that initializes the panel:

JPanel pane = new JPanel();
pane.setBorder(BorderFactory.createEmptyBorder(30, 30, 10, 30));
pane.setLayout(new GridLayout(0, 1));
pane.add(button);
pane.add(label);

The first line of code creates the panel. The second line adds a border to it. We'll discuss the border later.

The third line of code creates a layout manager that forces the panel's contents to be displayed in a single column. The last lines add the button and label to the panel. Adding the button and label to the panel means they are controlled by the panel's layout manager. Specifically, a container's layout manager determines the size and position of each component that's been added to the container.

Layout management concepts are discussed in Layout Management. To learn how to use individual layout managers, see Laying Out Components Within a Container.

Adding Borders Around Components

Here, again, is the code that adds a border to the panel:

pane.setBorder(BorderFactory.createEmptyBorder(
                                30, //top
                                30, //left
                                10, //bottom
                                30) //right
                                );

This border simply provides some empty space around the panel's contents -- 30 extra pixels on the top, left, and right, and 10 extra pixels on the bottom. Borders are a feature that JPanel inherits from the JComponent class.

Border concepts are discussed in Layout Management and Painting. See How to Use Borders for information about using the border API.

Handling Events

The SwingApplication example contains two event handlers. One handles button clicks (action events); the other handles window closing (window events). Here is the event-handling code from SwingApplication:

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        numClicks++;
        label.setText(labelPrefix + numClicks);
    }
});
...
frame.addWindowListener(new WindowAdapter() {
    public void windowClosing(WindowEvent e) {
	System.exit(0);
    }
});

You can read about Swing event handling in Event Handling and Writing Event Listeners.

Dealing with Thread Issues

The SwingApplication program is thread safe. Once its GUI is visible, its only GUI manipulation (updating the label) occurs in an event handler. Because the event handler runs in the same thread that performs all event handling and painting for the application, there's no possibility that two threads will try to manipulate the GUI at once.

However, it can be all too easy to introduce thread problems into a program. See Threads and Swing for information about thread safety in Swing.

Supporting Assistive Technologies

Support for assistive technologies -- devices such as screen readers that provide alternate ways of accessing information in a GUI -- is already included in every Swing component. The only code in SwingApplication that exists solely to support assistive technologies is this:

label.setLabelFor(button);

Assistive technologies can get plenty of information from Swing components, without any special code from you. For example, assistive technologies can automatically get the text information set by the following lines of code:

JButton button = new JButton("I'm a Swing button!");
label = new JLabel(labelPrefix + "0    ");
label.setText(labelPrefix + numClicks);
JFrame frame = new JFrame("SwingApplication");

See How to Support Assistive Technologies for more information about how you can ensure that your programs work well with tools that use the Accessibility API to query components.

Start of Tutorial > Start of Trail > Start of Lesson

Search Feedback Form