AhmadLang / Java, How To Program, 2004

mouse, the keyboard or another form of input, such as voice recognition. In this chapter and Chapter

22, GUI Components: Part 2, you will learn about many of Java's GUI components. [Note: Several concepts covered in this chapter have already been covered in the optional GUI and Graphics Case Study of Chapters 310. So, some material will be repetitive if you read the case study. You do not need to read the case study to understand this chapter.]

[Page 512 (continued)]

11.2. Simple GUI-Based Input/Output with JOptionPane

The applications in Chapters 210 display text at the command window and obtain input from the command window. Most applications you use on a daily basis use windows or dialog boxes (also called dialogs) to interact with the user. For example, e-mail programs allow you to type and read messages in a window provided by the e-mail program. Typically, dialog boxes are windows in which programs display important messages to the user or obtain information from the user. Java's JOptionPane class (package javax.swing) provides prepackaged dialog boxes for both input and output. These dialogs are displayed by invoking static JOptionPane methods. Figure 11.2 presents a simple addition application that uses two input dialogs to obtain integers from the user and a message dialog to display the sum of the integers the user enters.

Figure 11.2. JOptionPane input and message dialogs used to input values from the user and display results.

(This item is displayed on page 513 in the print version)

5public class Addition

6{

7public static void main( String args[] )

8{

9// obtain user input from JOptionPane input dialogs

10String firstNumber =

11JOptionPane.showInputDialog( "Enter first integer" );

12String secondNumber =

13JOptionPane.showInputDialog( "Enter second integer" );

15 // convert String inputs to int values for use in a calculation

16int number1 = Integer.parseInt( firstNumber );

17int number2 = Integer.parseInt( secondNumber );

19int sum = number1 + number2; // add numbers

21// display result in a JOptionPane message dialog

22JOptionPane.showMessageDialog( null, "The sum is " + sum,

23"Sum of Two Integers", JOptionPane.PLAIN_MESSAGE );

24} // end method main

25} // end class Addition

[View full size image]

Line 3 imports class JOptionPane for use in this application. Lines 1011 declare the local String variable firstNumber and assign it the result of the call JOptionPane static method showInputDialog. This method displays an input dialog (see the first screen capture in Fig. 11.2), using the method's String argument ("Enter first integer") as a prompt to the user.

[Page 514]

Look-and-Feel Observation 11.2

The prompt in an input dialog typically uses sentence-style capitalizationa style that capitalizes only the first letter of the first word in the text unless the word is a proper noun (for example, Deitel).

The user types characters in the text field, then clicks the OK button or presses the Enter key to submit the String to the program. Clicking OK also dismisses (hides) the dialog. [Note: If you type in the text field and nothing appears, activate the text field by clicking it with the mouse.] Unlike Scanner, which can be used to input values of several types from the user at the keyboard, an input dialog can input only input Strings. This is typical of most GUI components. Technically, the user can type anything in the input dialog's text field. Our program assumes that the user enters a valid integer value. If the user clicks the Cancel button, showInputDialog returns null. If the user either types a noninteger value or clicks the Cancel button in the input dialog, a runtime logic error will occur in this program and it will not operate correctly. Chapter 13, Exception Handling, discusses how to handle such errors. Lines 1213 display another input dialog that prompts the user to enter the second integer.

To perform the calculation in this application, we must convert the Strings that the user entered to int values. Recall from Section 7.12 that the Integer class's static method parseInt converts its String argument to an int value. Lines 1617 assign the converted values to local variables number1 and number2. Then, line 19 sums these values and assigns the result to local variable sum.

Lines 2223 use JOptionPane static method showMessageDialog to display a message dialog (the last screen capture of Fig. 11.2) containing the sum. The first argument helps the Java application determine where to position the dialog box. The value null indicates that the dialog should appear in

the center of the computer screen. The first argument can also be used to specify that the dialog should appear centered over a particular window, which we will demonstrate later in Section 11.8. The second argument is the message to displayin this case, the result of concatenating the String "The sum is " and the value of sum. The third argument"Sum of Two Integers"represents the string that should appear in the dialog's title bar at the top of the dialog. The fourth

argumentJOptionPane.PLAIN_MESSAGEis the type of message dialog to display. A PLAIN_MESSAGE dialog does not display an icon to the left of the message. Class JOptionPane provides several overloaded versions of methods showInputDialog and showMessageDialog, as well as methods that display other dialog types. For complete information on class JOptionPane, visit java.sun.com/j2se/1.5.0/docs/api/javax/swing/JOptionPane.html.

Look-and-Feel Observation 11.3

The title bar of a window typically uses book-title capitalizationa style that capitalizes the first letter of each significant word in the text and does not end with any punctuation (for example, Capitalization in a Book Title).

JOptionPane Message Dialog Constants

The constants that represent the message dialog types are shown in Fig. 11.3. All message dialog types except PLAIN_MESSAGE display an icon to the left of the message. These icons provide a visual indication of the message's importance to the user. Note that a QUESTION_MESSAGE icon is the default icon for an input dialog box (see Fig. 11.2).

Figure 11.3. JOptionPane static constants for message dialogs.

(This item is displayed on page 515 in the print version)

package java.awt, which were based on the GUI components of the underlying platform. For this reason, Swing GUI components are generally preferred.

Lightweight vs. Heavyweight GUI Components

Most Swing components are not tied to actual GUI components supported by the underlying platform on which an application executes. Such GUI components are known as lightweight components. AWT components (many of which parallel the Swing components), are tied to the local platform and are called heavyweight components, because they rely on the local platform's windowing system to determine their functionality and their look-and-feel.

Several Swing components are heavyweight components. Like AWT components, heavyweight Swing GUI components require direct interaction with the local windowing system, which may restrict their appearance and functionality. As you will learn, lightweight components provide you with more control over their appearance and functionality.

Look-and-Feel Observation 11.4

The look and feel of a GUI defined with heavyweight GUI components from package java.awt may vary across platforms. Because heavyweight components are tied to the local-platform GUI, the look and feel varies from platform to platform.

Superclasses of Swing's Lightweight GUI Components

The UML class diagram of Fig. 11.5 shows an inheritance hierarchy containing classes from which lightweight Swing components inherit their common attributes and behaviors. As discussed in Chapter 9, class Object is the superclass of the Java class hierarchy.

Figure 11.5. Common superclasses of many of the Swing components.

(This item is displayed on page 517 in the print version)

[View full size image]

Software Engineering Observation 11.1

Study the attributes and behaviors of the classes in the class hierarchy of Fig. 11.5. These classes declare the features that are common to most Swing components.

[Page 517]

Class Component (package java.awt) is a subclass of Object that declares many of the attributes and behaviors common to the GUI components in packages java.awt and javax.swing. Most GUI components extend class Component directly or indirectly. Visit java.sun.com/j2se/5.0/docs/api/java/awt/Component.html for a complete list of these common features.

Class Container (package java.awt) is a subclass of Component. As you will soon see, Components are attached to Containers (such as windows) so the Components can be organized and displayed on the screen. Any object that is a Container can be used to organize other Components in a GUI. Because a Container is a Component, you can attach Containers to other Containers to help organize a GUI. Visit java.sun.com/j2se/5.0/docs/api/java/awt/Container.html for a complete list of the Container features that are common to Swing lightweight components.

Class JComponent (package javax.swing) is a subclass of Container. JComponent is the superclass of all lightweight Swing components and declares their common attributes and behaviors. Because JComponent is a subclass of Container, all lightweight Swing components are also Containers. Some common lightweight component features supported by JComponent include:

1.A pluggable look-and-feel that can be used to customize the appearance of components (e.g., for use on particular platforms). You will see an example of this in Section 22.6.

2.Shortcut keys (called mnemonics) for direct access to GUI components through the keyboard. You will see an example of this in Section 22.4.

3.Common event-handling capabilities for cases where several GUI components initiate the same actions in an application.

4.Brief descriptions of a GUI component's purpose (called tool tips) that are displayed when the mouse cursor is positioned over the component for a short time. You will see an example of this in the next section.

5.Support for assistive technologies, such as braille screen readers for the visually impaired.

6.Support for user-interface localizationthat is, customizing the user interface to display in different languages and use local cultural conventions.

[Page 518]

These are just some of the many features of the Swing components. Visit java.sun.com/j2se/5.0/docs/api/javax/swing/JComponent.html for more details of the common lightweight component features.

18{

19super( "Testing JLabel" );

20setLayout( new FlowLayout() ); // set frame layout

22// JLabel constructor with a string argument

23label1 = new JLabel( "Label with text" );

24label1.setToolTipText( "This is label1" );

25add( label1 ); // add label1 to JFrame

27// JLabel constructor with string, Icon and alignment arguments

28Icon bug = new ImageIcon( getClass().getResource( "bug1.gif" ) );

29label2 = new JLabel( "Label with text and icon", bug,

30SwingConstants.LEFT );

31label2.setToolTipText( "This is label2" );

32add( label2 ); // add label2 to JFrame

33

34label3 = new JLabel(); // JLabel constructor no arguments

35label3.setText( "Label with icon and text at bottom" );

36label3.setIcon( bug ); // add icon to JLabel

37label3.setHorizontalTextPosition( SwingConstants.CENTER );

38label3.setVerticalTextPosition( SwingConstants.BOTTOM );

39label3.setToolTipText( "This is label3" );

40add( label3 ); // add label3 to JFrame

41} // end LabelFrame constructor

42} // end class LabelFrame

Figure 11.7. Test class for LabelFrame.

(This item is displayed on page 520 in the print version)

1// Fig. 11.7: LabelTest.java

2// Testing LabelFrame.

3import javax.swing.JFrame;

4

5public class LabelTest

6{

7public static void main( String args[] )

8{

9LabelFrame labelFrame = new LabelFrame(); // create LabelFrame

10labelFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11labelFrame.setSize( 275, 180 ); // set frame size

12labelFrame.setVisible( true ); // display frame

13} // end main

14} // end class LabelTest

[View full size image]