The first step in creating a Swing application is to create a class that represents the graphical user interface. An object of this class serves as a container that holds all the other components to be displayed.

In many projects, the main interface object is either a simple window (the JWindow class) or a more specialized window called a frame (the JFrame class).

A window is a container that can be displayed on a user’s desktop. A simple window does not have a title bar; Maximize, Minimize, or Close buttons; or other features you see on most windows that open in a graphical operating system. In Swing, windows that do have these features are called frames.

In a graphical environment such as Windows or Mac OS, users expect to have the ability to move, resize, and close the windows of programs that they run. The main place a simple window, rather than a frame, turns up is when programs are loading—there is sometimes a title screen with the program’s name, logo, and other information.

One way to create a graphical Swing application is to make the interface a subclass of JFrame, as in the following class declaration:

public class FeedReader extends JFrame {
    // ...
}

The constructor of the class should handle the following tasks:

The JFrame class has two constructors: JFrame() and JFrame(String). One sets the frame’s title bar to the specified text, and the other leaves the title bar empty. You also can set the title by calling the frame’s setTitle(String) method.

The size of a frame can be established by calling the setSize(int, int) method with the width and height as arguments. The size of a frame is indicated in pixels, so if you called setSize(650, 550), the frame would take up most of a screen at 800×600 resolution.

Another way to set the size of a frame is to fill the frame with the components it will contain and then call the frame’s pack() method. This resizes the frame based on the size of the components inside it. If the size of the frame is bigger than it needs to be, pack() shrinks it to the minimum size required to display the components. If the frame is too small (or the size has not been set at all), pack() expands it to the required size.

Frames are invisible when they are created. You can make them visible by calling the frame’s setVisible(boolean) method with the literal true as an argument.

If you want a frame to be displayed when it is created, call one of these methods in the constructor. You also can leave the frame invisible, requiring any class that uses the frame to make it visible by calling setVisible(true). (To hide a frame, call setVisible(false).)

When a frame is displayed, the default behavior is for it to be positioned in the upper-left corner of the computer’s desktop. You can specify a different location by calling the setBounds(int, int, int, int) method. The first two arguments to this method are the (x,y) position of the frame’s upper-left corner on the desktop. The last two arguments set the width and height of the frame.

The following class represents a 300×100 frame with “Edit Payroll” in the title bar:

public class Payroll extends javax.swing.JFrame {
    public Payroll() {
        super("Edit Payroll");
        setSize(300, 100);
        setVisible(true);
    }
}

Every frame has Maximize, Minimize, and Close buttons on the title bar at the user’s control—the same controls present in the interface of other software running on your system.

The normal behavior when a frame is closed is for the application to keep running. When a frame serves as a program’s main graphical user interface, this leaves a user with no way to stop the program.

To change this, you must call a frame’s setDefaultCloseOperation() method with one of four static variables of the JFrame class as an argument:

To prevent a user from closing a frame at all, add the following statement to the frame’s constructor method:

setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

If you are creating a frame to serve as an application’s main user interface, the expected behavior is probably EXIT_ON_CLOSE, which shuts down the application along with the frame.

Listing 9.1 contains a simple application that displays a frame 300×100 pixels in size. This class can serve as a framework—pun unavoidable—for any applications you create that use a graphical user interface.

 1: import javax.swing.JFrame;
 2:
 3: public class SimpleFrame extends JFrame {
 4:     public SimpleFrame() {
 5:         super("Frame Title");
 6:         setSize(300, 100);
 7:         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 8:         setVisible(true);
 9:     }
10:
11:     public static void main(String[] arguments) {
12:         SimpleFrame sf = new SimpleFrame();
13:     }
14: }

When you compile and run the application, you should see the frame displayed in Figure 9.1.

Figure 9.1. Displaying a frame.

The SimpleFrame application isn’t much to look at—the graphical user interface contains no components, aside from the standard Minimize, Maximize, and Close (X) buttons on the title bar shown in Figure 9.1. You will add components later today.

In the application, a SimpleFrame object is created in the main() method in lines 11–13. If you had not displayed the frame when it was constructed, you could call sf.setVisible(true) in the main() method to display the frame.

The work involved in creating the frame’s user interface takes place in the SimpleFrame() constructor. Components could be created and added to the frame within this constructor.

Creating a window using JWindow is similar to working with frames in Swing, but you can’t provide a title or close a window.

Listing 9.2 contains an application that creates and opens a window, changing its size from 0×0 to 400×400 before your eyes.

 1: import javax.swing.JWindow;
 2:
 3: public class SimpleWindow extends JWindow {
 4:     public SimpleWindow() {
 5:         super();
 6:         setBounds(400, 300, 10, 10);
 7:         setVisible(true);
 8:     }
 9:
10:     public static void main(String[] arguments) {
11:         SimpleWindow sw = new SimpleWindow();
12:         for (int i = 10; i < 400; i++) {
13:             sw.setBounds(400 - (i/2), 300 - (i/2), i, i);
14:         }
15:     }
16: }

In the application, the call to setBounds(400, 300, 10, 10) in line 6 of Listing 9.2 sets the window to be 10×10 in size and displayed with its upper-left corner at the (x,y) position 400, 300.

The for loop in lines 12–14 changes the size of the window and moves its upper-left corner with each iteration. The window grows from 10×10 in size to 400×400 as the loop progresses. You can close the window and application by pressing Ctrl+C on your keyboard.

The lack of adornment on a JWindow component makes it suitable for use as a splash page, a graphic or text that displays as an application loads.

Java 6 adds a better, faster way to do this by defining a graphic that functions as an application’s splash. The graphic loads even before the Java interpreter and disappears when the application begins running.

The graphic can be specified with the -splash attribute when the class is run at a command line. Here’s how to do it with the SimpleWindow class:

java -splash:lighthouse.jpg SimpleWindow

Another technique to define a splash graphic is covered on Day 14, “Developing Swing Applications.”

Creating a graphical user interface is a great way to get experience working with objects in Java because each interface component is represented by its own class.

To use an interface component in Java, you create an object of that component’s class. You already have worked with the container classes JFrame and JWindow.

One of the simplest components to employ is JButton, the class that represents clickable buttons.

In most programs, buttons trigger an action—click Install to begin installing software, click a smiley button to begin a new game of Minesweeper, click the Minimize button to prevent your boss from seeing Minesweeper running, and so on.

A Swing button can feature a text label, a graphical icon, or a combination of both.

Constructors you can use for buttons include the following:

The following statements create three buttons with text labels:

JButton play = new JButton("Play");
JButton stop = new JButton("Stop");
JButton rewind = new JButton("Rewind");

Graphical buttons are covered later today.

Before you can display a user interface component such as a button in a Java program, you must add it to a container and display that container.

To add a component to a container, call the container’s add(Component) method with the component as the argument (all user interface components in Swing inherit from java.awt.Component).

The simplest Swing container is a panel (the JPanel class). The following example creates a button and adds it to a panel:

JButton quit = new JButton("Quit");
JPanel panel = new JPanel();
panel.add(quit);

Use the same technique to add components to frames and windows.

The program in Listing 9.3 uses the application framework created earlier in this lesson. A panel is created, three buttons are added to the panel, and then it is added to a frame.

 1: import javax.swing.*;
 2:
 3: public class ButtonFrame extends JFrame {
 4:     JButton load = new JButton("Load");
 5:     JButton save = new JButton("Save");
 6:     JButton unsubscribe = new JButton("Unsubscribe");
 7:
 8:     public ButtonFrame() {
 9:         super("Button Frame");
10:         setSize(140, 170);
11:         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
12:         JPanel pane = new JPanel();
13:         pane.add(load);
14:         pane.add(save);
15:         pane.add(unsubscribe);
16:         add(pane);
17:         setVisible(true);
18: }
19:
20:     public static void main(String[] arguments) {
21:         ButtonFrame bf = new ButtonFrame();
22:     }
23: }

When you run the application, a small frame opens that contains the three buttons (see Figure 9.2).

Figure 9.2. The ButtonFrame application.

The ButtonFrame class has three instance variables: the load, save, and unsubscribe JButton objects.

In lines 12–15, a new JPanel object is created, and the three buttons are added to the panel by calls to its add() method. When the panel contains all the buttons, the frame’s add() method is called in line 16 with the panel as an argument, adding it to the frame.

Swing supports the use of graphical ImageIcon objects on buttons and other components in which a label can be provided. An icon is a small graphic that can be placed on a button, label, or other user interface element to identify it—such as a garbage can or recycling bin icon for deleting files, folder icons for opening and storing files, and the like.

An ImageIcon object can be created by specifying the filename of a graphic as the only argument to the constructor. The following example loads an icon from the graphics file subscribe.gif and creates a JButton with the icon as its label:

ImageIcon subscribe = new ImageIcon("subscribe.gif");
JButton button = new JButton(subscribe);
JPanel pane = new JPanel();
pane.add(button);
add(pane);
setVisible(true);

Listing 9.4 contains a Java application that creates four image icons with text labels, adds them to a panel, and then adds the panel to a frame.

 1: import javax.swing.*;
 2:
 3: public class IconFrame extends JFrame {
 4:     JButton load, save, subscribe, unsubscribe;
 5:
 6:     public IconFrame() {
 7:         super("Icon Frame");
 8:         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 9:         JPanel panel = new JPanel();
10:         // create icons
11:         ImageIcon loadIcon = new ImageIcon("load.gif");
12:         ImageIcon saveIcon = new ImageIcon("save.gif");
13:         ImageIcon subscribeIcon = new ImageIcon("subscribe.gif");
14:         ImageIcon unsubscribeIcon = new ImageIcon("unsubscribe.gif");
15:         // create buttons
16:         load = new JButton("Load", loadIcon);
17:         save = new JButton("Save", saveIcon);
18:         subscribe = new JButton("Subscribe", subscribeIcon);
19:         unsubscribe = new JButton("Unsubscribe", unsubscribeIcon);
20:         // add buttons to panel
21:         panel.add(load);
22:         panel.add(save);
23:         panel.add(subscribe);
24:         panel.add(unsubscribe);
25:         // add the panel to a frame
26:         add(panel);
27:         pack();
28:         setVisible(true);
29:     }
30:
31:     public static void main(String[] arguments) {
32:         IconFrame ike = new IconFrame();
33:     }
34: }

Figure 9.3 shows the result.

Figure 9.3. An interface containing buttons labeled with icons.

The icons’ graphics referred to in lines 11–14 can be found on this book’s official website at http://www.java21days.com on the Day 9 page.

The IconFrame application does not set the size of the frame in pixels. Instead, the pack() method is called in line 27 to expand the frame to the minimum size required to present the four buttons next to each other.

If the frame were set to be tall rather than wide—for instance, by calling setSize(100, 400) in the constructor—the buttons would be stacked vertically.

http://java.sun.com/developer/techDocs/hi/repository

A label is a user component that holds text, an icon, or both. Labels, which are created from the JLabel class, often are used to identify the purpose of other components on an interface. They cannot be directly edited by a user.

To create a label, you can use the following constructors:

The alignment of a label determines how its text or icon is aligned in relation to the area taken up by the window. Three static class variables of the SwingConstants interface are used to specify alignment: LEFT, CENTER, and RIGHT.

The contents of a label can be set with setText(String) or setIcon(Icon) methods. You also can retrieve these things with getText() and getIcon() methods.

The following statements create three labels with left, center, and right alignment, respectively:

JLabel feedsLabel = new JLabel("Feeds", SwingConstants.LEFT);
JLabel urlLabel = new JLabel("URL: ", SwingConstants.CENTER);
JLabel dateLabel = new JLabel("Date: ", SwingConstants.RIGHT);

A text field is a location on an interface where a user can enter and modify text using the keyboard. Text fields are represented by the JTextField class, and each can handle one line of input. Later in this section, you will see a similar component called a text area that can handle multiple lines.

Constructors for text fields include the following:

A text field’s width attribute has relevance only if the interface is organized in a manner that does not resize components. You will get more experience with this when you work with layout managers on Day 11, “Arranging Components on a User Interface.”

The following statements create an empty text field that has enough space for roughly 60 characters and a text field of the same size with the starting text “Enter RSS feed URL here”:

JTextField rssUrl = new JTextField(60);
JTextField rssUrl2 = new JTextField(
    "Enter RSS feed URL here", 60);

Text fields and text areas both inherit from the superclass JTextComponent and share many common methods.

The setEditable(boolean) method determines whether a text component can be edited (true) or not (false). There’s also an isEditable() method that returns a corresponding boolean value.

The setText(String) method changes the text to the specified string, and the getText() method returns the component’s current text as a string. Another method retrieves only the text that a user has highlighted in the getSelectedText() component.

Password fields are text fields that hide the characters a user is typing into the field. They are represented by the JPasswordField class, a subclass of JTextField. The JPasswordField constructor methods take the same arguments as those of its parent class.

After you have created a password field, call its setEchoChar(char) method to obscure input by replacing each input character with the specified character.

The following statements create a password field and set its echo character to “#”:

JPasswordField codePhrase = new JPasswordField(20);
codePhrase.setEchoChar('#'),

Text areas, editable text fields that can handle more than one line of input, are implemented with the JTextArea class.

JTextArea includes the following constructors:

You can use the getText(), getSelectedText(), and setText(String) methods with text areas as you would text fields. Also, an append(String) method adds the specified text at the end of the current text, and an insert(String, int) method inserts the specified text at the indicated position.

The setLineWrap(boolean) method determines whether text will wrap to the next line when it reaches the right edge of the component. Call setLineWrap(true) to cause line wrapping to occur.

The setWrapStyleWord(boolean) method determines what wraps to the next line—either the current word (true) or the current character (false).

The next project you will create, the Authenticator application in Listing 9.5, uses several Swing components to collect user input: a text field, a password field, and a text area. Labels also are used to indicate the purpose of each text component.

 1: import javax.swing.*;
 2:
 3: public class Authenticator extends javax.swing.JFrame {
 4:     JTextField username = new JTextField(15);
 5:     JPasswordField password = new JPasswordField(15);
 6:     JTextArea comments = new JTextArea(4, 15);
 7:     JButton ok = new JButton("OK");
 8:     JButton cancel = new JButton("Cancel");
 9:
10:     public Authenticator() {
11:         super("Account Information");
12:         setSize(300, 220);
13:         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14:
15:         JPanel pane = new JPanel();
16:         JLabel usernameLabel = new JLabel("Username: ");
17:         JLabel passwordLabel = new JLabel("Password: ");
18:         JLabel commentsLabel = new JLabel("Comments: ");
19:         comments.setLineWrap(true);
20:         comments.setWrapStyleWord(true);
21:         pane.add(usernameLabel);
22:         pane.add(username);
23:         pane.add(passwordLabel);
24:         pane.add(password);
25:         pane.add(commentsLabel);
26:         pane.add(comments);
27:         pane.add(ok);
28:         pane.add(cancel);
29:         add(pane);
30:         setVisible(true);
31:     }
32:
33:     public static void main(String[] arguments) {
34:         Authenticator auth = new Authenticator();
35:     }
36: }

Figure 9.4 shows the application in use. The password is obscured with asterisk characters (“*”), which is the default when no other echo character is designated by calling the field’s setEchoChar(char) method.

Figure 9.4. The Authenticator application.

The text area in this application behaves in a manner that you might not expect. When you reach the bottom of the field and continue entering text, the component grows to make more room for input. The next section describes how to add scrollbars to prevent the area from changing in. size.

Text areas in Swing do not include horizontal or vertical scrollbars, and there’s no way to add them using this component alone.

Swing supports scrollbars through a new container that can be used to hold any component that can be scrolled: JScrollPane.

A scrolling pane is associated with a component in the pane’s constructor. You can use either of the following constructors:

There also are three similarly named variables for horizontal scrollbars.

After you create a scrolling pane containing a component, the pane should be added to containers in place of that component.

The following example creates a text area with a vertical scrollbar and no horizontal scrollbar and then adds it to a content pane:

JPanel pane = new JPanel();
JTextArea comments = new JTextArea(4, 15);
JScrollPane scroll = new JScrollPane(comments,
    ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
    ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
pane.add(scroll);
setContentPane(pane);

The next two components you will learn about, check boxes and radio buttons, hold only two possible values: selected or not selected.

Check boxes are used to make a simple choice in an interface, such as yes-no or on-off. Radio buttons are grouped together so that only one button can be selected at any time.

Check boxes (the JCheckBox class) appear as labeled or unlabeled boxes that contain a check mark when they are selected and nothing otherwise. Radio buttons (the JRadioButton class) appear as circles that contain a dot when selected and are also empty otherwise.

Both the JCheckBox and JRadioButton classes have several useful methods inherited from a common superclass:

The following constructors are available for the JCheckBox class:

The JRadioButton class has constructors with the same arguments and functionality.

Check boxes and radio buttons by themselves are nonexclusive, meaning that if you have five check boxes in a container, all five can be checked or unchecked at the same time. To make them exclusive, as radio buttons should be, you must organize related components into groups.

To organize several radio buttons into a group, allowing only one to be selected at a time, create a ButtonGroup class object, as demonstrated in the following statement:

ButtonGroup choice = new ButtonGroup();

The ButtonGroup object keeps track of all radio buttons in its group. Call the group’s add(Component) method to add the specified component to the group.

The following example creates a group and two radio buttons that belong to it:

ButtonGroup saveFormat = new ButtonGroup();
JRadioButton s1 = new JRadioButton("OPML", false);
saveFormat.add(s1);
JRadioButton s2 = new JRadioButton("XML", true);
saveFormat.add(s2);

The saveFormat object is used to group together the s1 and s2 radio buttons. The s2 object, which has the label "XML", is selected. Only one member of the group can be selected at a time—if one component is selected, the ButtonGroup object makes sure that all others in the group are deselected.

Listing 9.6 contains an application with four radio buttons in a group.

 1: import javax.swing.*;
 2:
 3: public class FormatFrame extends JFrame {
 4:     JRadioButton[] teams = new JRadioButton[4];
 5:
 6:     public FormatFrame() {
 7:         super("Choose an Output Format");
 8:         setSize(320, 120);
 9:         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
10:         teams[0] = new JRadioButton("Atom");
11:         teams[1] = new JRadioButton("RSS 0.92");
12:         teams[2] = new JRadioButton("RSS 1.0");
13:         teams[3] = new JRadioButton("RSS 2.0", true);
14:         JPanel panel = new JPanel();
15:         JLabel chooseLabel = new JLabel(
16:             "Choose an output format for syndicated news items.");
17:         panel.add(chooseLabel);
18:         ButtonGroup group = new ButtonGroup();
19:         for (int i = 0; i < teams.length; i++) {
20:             group.add(teams[i]);
21:             panel.add(teams[i]);
22:         }
23:         add(panel);
24:         setVisible(true);
25:     }
26:
27:     public static void main(String[] arguments) {
28:         FormatFrame ff = new FormatFrame();
29:     }
30: }

Figure 9.5 shows the application running. The four JRadioButton objects are stored in an array, and in the for loop in lines 19–22 each element is first added to a button group and then added to a panel. After the loop ends, the panel is used for the application’s content pane.

Figure 9.5. The FormatFrame application.

Choosing one of the radio buttons causes the existing choice to be deselected.

The Swing class JComboBox can be used to create combo boxes, components that present a drop-down menu from which a single value can be selected. By hiding the menu when the component is not being used, it takes up less space in a graphical user interface.

The following steps show how a combo box can be created:

In a combo box, users will be able to select only one of the items in the drop-down menu. If the component’s setEditable() method is called with true as an argument, it also supports the entry of text. This feature gives combo boxes their name—a component configured in this manner serves as both a drop-down menu and a text field.

The JComboBox class has several methods that can be used to control a drop-down list or combo box:

The FormatFrame2 application in Listing 9.7 contains an application that rewrites the preceding radio button example. The program uses an uneditable combo box to choose one of four options.

 1: import javax.swing.*;
 2:
 3: public class FormatFrame2 extends JFrame {
 4:     String[] formats = { "Atom", "RSS 0.92", "RSS 1.0", "RSS 2.0" };
 5:     JComboBox formatBox = new JComboBox();
 6:
 7:     public FormatFrame2() {
 8:         super("Choose a Format");
 9:         setSize(220, 150);
10:         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
11:         JPanel pane = new JPanel();
12:         JLabel formatLabel = new JLabel("Output formats:");
13:         pane.add(formatLabel);
14:         for (int i = 0; i < formats.length; i++)
15:             formatBox.addItem(formats[i]);
16:         pane.add(formatBox);
17:         add(pane);
18:         setVisible(true);
19:     }
20:
21:     public static void main(String[] arguments) {
22:         FormatFrame2 ff = new FormatFrame2();
23:     }
24: }

Figure 9.6 shows the application as the combo box is expanded so that a value can be selected.

Figure 9.6. The FormatFrame2 application.

The following question is the kind of thing you could expect to be asked on a Java programming certification test. Answer it without looking at today’s material or using the Java compiler to test the code.

Given:

import javax.swing.*;

public class Display extends JFrame {
    public Display() {
        super("Display");
        // answer goes here
        JLabel hello = new JLabel("Hello");
        JPanel pane = new JPanel();
        pane.add(hello);
        setContentPane(pane);
        pack();
        setVisible(true);
    }

    public static void main(String[] arguments) {
        Display ds = new Display();
    }
}

The answer is available on the book’s website at http://www.java21days.com. Visit the Day 9 page and click the Certification Practice link.