Swinging into Swing

So far in this book, all the programs have been console based, like something right out of the 1980s. Console-based Java programs have their place, especially when you're first learning about Java. But eventually, you'll want to create programs that work with a Graphical User Interface, also known as a GUI.

This chapter gets you started in that direction. You create simple GUI applications that display simple buttons and text labels. Along the way, you find out about two key classes: JFrame and JPanel, which provide the visual containers that hold buttons, labels, and other components I discuss in later chapters.

Some Important Swing Concepts You Need to Know

Learning Swing is one of the most complicated tasks of learning Java. Complicated enough, in fact, that I have to go over some conceptual information before I get into the nitty-gritty of writing GUI code. So put on your thinking cap for the next few sections.

Understanding what Swing does

Swing is a package that lets you create applications that use a flashy Graphical User Interface (or GUI) instead of a dull console interface. Figure 1-1 shows a typical window created with Swing. As you can see, this window includes a variety of user-interface components, including labels, text fields, drop-down lists, and buttons.

Figure 1-1: A typical Swing window.

The Swing class hierarchy

The Swing API provides many different classes for creating various types of user-interface elements. In this chapter, I look at three of those classes: JFrame, JPanel, and JLabel. However, these three classes are part of a larger collection of classes that are all related through inheritance, as shown in Figure 1-2. The Swing family tree splits at the Component class into one group of classes that are derived from the JComponent class, and another branch that descends from the Window class.

Figure 1-2: The Swing family tree.

The following paragraphs briefly describe each of the classes shown in this figure:

• Object: All classes ultimately derive from Object, so it's no surprise that this class is at the top of the tree.
• Component: The Component class represents an object that has a visual representation that can be shown on-screen and that can interact with users. This class defines some basic methods that are available to all Swing classes. For example, the setVisible method determines whether a component is visible or hidden. And the setBounds method sets the location and size of the component. This is an AWT class, not a Swing class.
• Container: The Container class builds on the basic visual capabilities of the Component class by adding the ability to hold other containers. This too is an AWT class rather than a Swing class. From this class, you get the add method, which lets you add components to a container. As you'll see, you use this method in almost all GUI programs.
• Window: This class defines a window: a specialized type of container object that has a border, a title bar, and buttons that minimize, maximize, and close it-and that the user can reposition (possibly even resize).
• Frame: A frame is a type of Window that serves as the basis for Java GUI applications. Frame is an AWT class that has been improved upon by the JFrame class.
• JFrame: The Swing version of the older Frame class. Most of your Swing applications include at least one JFrame object.
• JComponent: The JComponent class is a Swing class that is the basis for all other Swing components except for frames.
• JPanel: This class creates panels, which are containers used to organize and control the layout of other components such as labels, buttons, text fields, and so on. In most Swing applications, one or more panels are added to a frame. Then, when the frame is displayed, the components that were added to its panels are made visible.
• JLabel: This class creates a label that displays a simple text value.

In addition, you'll find that some Swing features use classes in the java.awt and java.awt.event packages. So you may need to import those packages as well.

I ve Been Framed!

The top-level component for most Swing-based applications is called a frame and is defined by the JFrame class. By itself, a frame doesn't do much. But to do anything else in Swing, you must first create a frame. Figure 1-3 shows a frame that does nothing but display the message Hello, World! in its title bar.

Figure 1-3: The frame displayed by the Hello, World! program.

The JFrame has about a bazillion methods, but only a few of them are useful in most programs. Table 1-1 lists the JFrame methods you use most, along with a couple of constructors.

Table 1-1: Useful JFrame Constructors and Methods

Open table as spreadsheet

Open table as spreadsheet

Open table as spreadsheet

At the minimum, you want to set a title for a new frame, set the frame's size so it's large enough to see any components you add to it (by default, the frame is zero pixels wide and zero pixels high, so it isn't very useful), and call the setVisible method to make the frame visible. One way to do these three things is to create an instance of the JFrame class and set its properties using statements like this:

JFrame frame = new JFrame("This is the title"); frame.setSize(350, 260); frame.setVisible(true);

A more common approach, however, is to create a frame by declaring a class that extends the JFrame class. Then you call these methods in the constructor, as I describe in the next section.

Hello, World! in Swing

To get you started with Swing, Listing 1-1 shows a Swing version of the classic Hello, World! program, using nothing but a frame. If you run this program, the frame shown in Figure 1-1 is displayed on-screen. As you can see, the frame's title bar contains the text “Hello, World!”

The purpose of this seemingly pointless little program is to illustrate one solution to the first problem you encounter when you work with Swing: The main method is a static method, but Swing frames are objects-so you have to figure out how to get your program out of a static context. This program does that by creating the application as a class that extends JFrame. Then, the main method calls the class constructor, in effect creating an instance of itself. That's all the main method does; the real work of this application is done by the constructor.

Listing 1-1: The Swing Version of the Hello, World! Program

import javax.swing.*; → 1 public class HelloFrame extends JFrame → 3 { public static void main(String[] args) → 5 { new HelloFrame(); → 7 } public HelloFrame() → 10 { this.setSize(200,100); → 12 this.setDefaultCloseOperation( → 13 JFrame.EXIT_ON_CLOSE); this.setTitle("Hello World!"); → 15 this.setVisible(true); → 16 } }

The following paragraphs describe most of the features of this program:

Open table as spreadsheet

That's all there is to this program. Granted, it's a little more complicated than the console-based Hello, World! program from Book I, Chapter 1. But not by much. Just to be sure its operation is clear, here's a recap of what happens when this program is run:

1. Java runs the static main method for the HelloWorld class.
2. The main method creates an instance of the HelloWorld class, which causes the constructor to be executed.
3. The constructor sets the frame size, the default close operation, and the title.
4. Now that the constructor is done, the program continues with the main method, where the setVisible method is called to display the frame.

Positioning the Frame On Screen

The JFrame class provides two methods that let you specify the position of the frame on-screen. If you want to place the frame at some arbitrary location on-screen, use the setLocation method. For example, to put the frame at the top-left corner of the screen, use this statement:

frame.setLocation(0,0);

This method is designed to let you position a frame relative to some other component that's already displayed. But if you pass null as the parameter, the method centers the frame on-screen.

If you want to position a window at some location other than the top-left corner or dead center on-screen, you may need to know the width and height of the user's screen so you can calculate a location for your frame. To determine the size of the user's screen, you can use a class named Toolkit. The Toolkit class has a bunch of methods, but you need to know two of them here:

• getDefaultToolkit: A static method that creates a Toolkit object. You must use this method before you can use the getScreenSize method.
• getScreenSize: Returns the size of the screen as a Dimension object.

The Dimension class has two public fields that represent the size of the screen: height and width. Both fields are of type int.

Suppose you want to position a frame so that its bottom-left corner is right at the center of the screen. The following code, placed in the frame's constructor, does the trick:

Toolkit tk = Toolkit.getDefaultToolkit(); Dimension d = tk.getScreenSize(); int x = d.width / 2; int y = (d.height / 2) - this.getHeight(); this.setLocation(x, y);

This code first creates a Toolkit object and uses it to get the screen dimensions. It sets the x position to the horizontal center of the screen by dividing the screen width by 2. Then it sets the y position to the vertical center (the screen height divided by 2) less the width of the frame. That puts the bottom of the frame at the vertical midpoint.

Using the JPanel Class

A panel is a type of container that's designed to hold a group of components so they can be displayed on a frame. The normal way to display a group of controls such as text fields, labels, buttons, and other GUI widgets is to add those controls to a panel, and then add the panel to the frame. You can bypass the panel and add the controls directly to the frame if you want, but using a separate panel to hold the frame's control is almost always a good idea.

Panels are defined by the JPanel class. Like the JFrame class, the JPanel class has a bevy of methods. Table 1-2 lists the most commonly used constructors and methods for the JPanel class.

Table 1-2: Interesting JPanel Constructors and Methods

Open table as spreadsheet

Open table as spreadsheet

You can use several different techniques to create a panel and add it to a frame. One is to simply create a JPanel object and assign it to a variable in the JFrame constructor. You can then add components to the panel, and then add the panel to the frame. For example

// HelloFrame constructor public HelloFrame() { this.setSize(200,100); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setTitle("Hello, World!"); JPanel panel = new JPanel(); // code to add components to the panel goes here this.setVisible(true); }

Another commonly used technique is to create a separate class for the panel. This class should extend JPanel. Then you can add any components the panel needs in the constructor:

class HelloPanel extends JPanel { public HelloPanel() { // code to add components to the panel goes here } }

Then, in the frame class constructor, you create a new instance of the panel class and add it to the panel:

HelloPanel panel = new HelloPanel(); this.add(panel);

Or, just this statement does the trick:

this.add(new HelloPanel());

Using Labels

Now that you know how to create frames and panels, you can create a useful component to add to a panel: a label. A label is a component that simply displays text. Labels are used for a variety of purposes: to display captions for other controls such as text fields or combo boxes, to display informational messages, or to show the results of a calculation or a database lookup.

To create a label, you use the JLabel class. Table 1-3 shows its most commonly used constructors and methods.

Table 1-3: Tolerable JLabel Constructors and Methods

Open table as spreadsheet

Open table as spreadsheet

When you create a label, you can pass the text you want it to display to the constructor, like this:

JLabel label1 = new JLabel("Hello, World!");

Or, you can create the label first, and then set its text later:

JLabel label1 = new JLabel(); label1.setText("Hello, World!");

A label won't be displayed until you add it to a panel that is (in turn) added to a frame. Here's an example of a constructor for a frame class that creates a panel, creates a label, adds the label to the panel, and adds the panel to the frame:

// HelloFrame constructor public HelloFrame() { this.setSize(200,100); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setTitle("Hello, World!"); JPanel panel1 = new JPanel(); JLabel label1 = new JLabel("Hello, World!") panel1.add(label1); this.add(panel1); this.setVisible(true); }

Figure 1-4 shows what this frame looks like when the program is run.

Figure 1-4: A frame with a panel, which has a label.

Creating Buttons

Next to labels, the Swing component you use most is the JButton component, which creates a button the user can click. Figure 1-5 shows a frame with a single button.

Figure 1-5: A frame with a panel, which includes a button.

In the next chapter, you find out how to write the code that responds when the user clicks a button. Here I just focus on how to create buttons and control their appearance. Table 1-4 lists the most commonly used constructors and methods that are available for the JButton class.

Table 1-4: Worthwhile JButton Constructors and Methods

Open table as spreadsheet

Open table as spreadsheet

Open table as spreadsheet

As you can see, the constructors for the JButton class are similar to the constructors for the JLabel class: You can either create an empty button or a button with text. For example, here's the code that creates the button shown in Figure 1-5:

JButton button1 = new JButton("Click me!");

If you don't provide the button text when you call the constructor, you can supply it later via the setText method, like this:

JButton button1 = new JButton(); button1.setText("Click me!");

Most of the other methods listed in Table 1-4 simply affect how a button looks. To disable a button so the user can't click it, call setEnabled(false). To remove the dark border from the edges of a button, call setBorderPainted (false). To remove the background from a button so all that's displayed is the text, call setContentAreaFilled(false). And to make a button disappear altogether, call setVisible(false).

A Word about the Layout of Components

Controlling the layout of components on a panel is one of the hardest things about using Swing. Hard enough, in fact, that I devote Book VI, Chapter 5 to it. Until then, you need to know a few key points:

• The layout of components on a panel (or frame) is controlled by a layout manager, which determines the final placement of each component. The layout manager takes the size of the component, the size of the panel, and the position of other nearby components into account when it makes its decisions.
• Swing provides several different layout managers you can choose from. Each has is own way of deciding where each component goes.
• The default layout manager for panels is called FlowLayout. It places components one after another in a row, and starts a new row only when it gets to the end of the panel (or the frame that contains it).
• With FlowLayout (and with the other layout managers too), the layout changes if the user changes the size of the frame. The size of the frame makes a big difference in how FlowLayout arranges controls.

• REMEMBER

  You can always call the frame's setResizeable(false) method to prevent the user from resizing the frame.

• If you want to change the layout manager used for a panel, you call the panel's setLayout method.

• Tip

  For many (if not most) Swing applications, you use more than one panel to display your components. Each panel can have a different layout manager. With this technique, you can create complex layouts with lots of components-all arranged just the way you want.

• If you need to, you can always turn off the layout manager altogether. To do that, you call the panel's setLayout method with null set as the parameter. Then, you use absolute positioning, which lets you set the x and y position and the size of each component by calling its setBounds method.
• This list could go on and on. For more information about controlling layout, refer to Book VI, Chapter 5.