Buttons that Maintain State

The Swing GUI components contain three types of state buttonsJToggleButton, JCheckBox and JRadioButtonthat have on/off or true/false values. Classes JCheckBox and JRadioButton are subclasses of JToggleButton (Fig. 11.14). A JRadioButton is different from a JCheckBox in that normally several JRadioButtons are grouped together, and are mutually exclusiveonly one in the group can be selected at any time. We first discuss class JCheckBox. The next two subsections also demonstrate that an inner class can access the members of its top-level class.

11.9.1. JCheckBox

The application of Fig. 11.17 and Fig. 11.18 uses two JCheckBox objects to select the desired font style of the text displayed in a JTextField. When selected, one applies a bold style and the other an italic style. If both are selected, the style of the font is bold and italic. When the application initially executes, neither JCheckBox is checked (i.e., they are both false), so the font is plain. Class CheckBoxTest (Fig. 11.18) contains the main method that executes this application.

Figure 11.17. JCheckBox buttons and item events.

(This item is displayed on pages 537 - 538 in the print version)

 1 // Fig. 11.17: CheckBoxFrame.java
 2 // Creating JCheckBox buttons.
 3 import java.awt.FlowLayout;
 4 import java.awt.Font;
 5 import java.awt.event.ItemListener;
 6 import java.awt.event.ItemEvent;
 7 import javax.swing.JFrame;
 8 import javax.swing.JTextField;
 9 import javax.swing.JCheckBox;
10
11 public class CheckBoxFrame extends JFrame
12 {
13 private JTextField textField; // displays text in changing fonts
14 private JCheckBox boldJCheckBox; // to select/deselect bold 
15 private JCheckBox italicJCheckBox; // to select/deselect italic
16
17 // CheckBoxFrame constructor adds JCheckBoxes to JFrame
18 public CheckBoxFrame()
19 {
20 super( "JCheckBox Test" );
21 setLayout( new FlowLayout() ); // set frame layout
22
23 // set up JTextField and set its font
24 textField = new JTextField( "Watch the font style change", 20 );
25 textField.setFont( new Font( "Serif", Font.PLAIN, 14 ) );
26 add( textField ); // add textField to JFrame
27
28 boldJCheckBox = new JCheckBox( "Bold" ); // create bold checkbox
29 italicJCheckBox = new JCheckBox( "Italic" ); // create italic 
30 add( boldJCheckBox ); // add bold checkbox to JFrame
31 add( italicJCheckBox ); // add italic checkbox to JFrame
32
33 // register listeners for JCheckBoxes 
34 CheckBoxHandler handler = new CheckBoxHandler();
35 boldJCheckBox.addItemListener( handler ); 
36 italicJCheckBox.addItemListener( handler ); 
37 } // end CheckBoxFrame constructor
38
39 // private inner class for ItemListener event handling
40 private class CheckBoxHandler implements ItemListener
41 {
42 private int valBold = Font.PLAIN; // controls bold font style
43 private int valItalic = Font.PLAIN; // controls italic font style
44
45 // respond to checkbox events 
46 public void itemStateChanged( ItemEvent event )
47 {
48 // process bold checkbox events
49 if ( event.getSource() == boldJCheckBox )
50 valBold =
51 boldJCheckBox.isSelected() ? Font.BOLD : Font.PLAIN;
52
53 // process italic checkbox events
54 if ( event.getSource() == italicJCheckBox )
55 valItalic =
56 italicJCheckBox.isSelected() ? Font.ITALIC : Font.PLAIN;
57
58 // set text field font
59 textField.setFont(
60 new Font( "Serif", valBold + valItalic, 14 ) );
61 } // end method itemStateChanged
62 } // end private inner class CheckBoxHandler
63 } // end class CheckBoxFrame

Figure 11.18. Test class for CheckBoxFrame.

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

 1 // Fig. 11.18: CheckBoxTest.java
 2 // Testing CheckBoxFrame.
 3 import javax.swing.JFrame;
 4
 5 public class CheckBoxTest
 6 {
 7 public static void main( String args[] )
 8 {
 9 CheckBoxFrame checkBoxFrame = new CheckBoxFrame();
10 checkBoxFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
11 checkBoxFrame.setSize( 275, 100 ); // set frame size
12 checkBoxFrame.setVisible( true ); // display frame
13 } // end main
14 } // end class CheckBoxTest

 

After the JTextField is created and initialized (Fig. 11.17, line 24), line 25 uses method setFont (inherited by JTextField indirectly from class Component) to set the font of the JTextField to a new object of class Font (package java.awt). The new Font is initialized with "Serif" (a generic font name representing a font such as Times and is supported on all Java platforms), Font.PLAIN style and 14-point size. Next, lines 2829 create two JCheckBox objects. The string passed to the JCheckBox constructor is the checkbox label that appears to the right of the JCheckBox by default.

When the user clicks a JCheckBox, an ItemEvent occurs. This event can be handled by an ItemListener object, which must implement method itemStateChanged. In this example, the event handling is performed by an instance of private inner class CheckBoxHandler (lines 4062). Lines 3436 create an instance of class CheckBoxHandler and register it with method addItemListener as the listener for both the JCheckBox objects.

Lines 4243 declare instance variables for the inner class CheckBoxHandler. Together, these variables represent the font style for the text displayed in the JTextField. Initially both are Font.PLAIN to indicate that the font is not bold and is not italic. Method itemStateChanged (lines 4661) is called when the user clicks the bold or the italic JCheckBox. The method uses event.getSource() to determine which JCheckBox the user clicked. If it was the boldJCheckBox, line 51 uses JCheckBox method isSelected to determine if the JCheckBox is selected (i.e., it is checked). If the checkbox is selected, local variable valBold is assigned Font.BOLD; otherwise, it is assigned Font.PLAIN. A similar statement executes if the user clicks the italicJCheckBox. If the italicJCheckBox is selected, local variable valItalic is assigned Font.ITALIC; otherwise, it is assigned Font.PLAIN. Lines 5960 change the font of the JTextField, using the same font name and point size. The sum of valBold and valItalic represents the JTextField's new font style. Each of the Font constants represents a unique value. Font.PLAIN has the value 0, so if both valBold and valItalic are set to Font.PLAIN, the font will have the plain style. If one of the values is Font.BOLD or Font.ITALIC, the font will be bold or italic accordingly. If one is BOLD and the other is ITALIC, the font will be both bold and italic.

Relationship Between an Inner Class and Its Top-Level Class

You may have noticed that class CheckBoxHandler used variables boldJCheckBox (Fig. 11.17, lines 49 and 51), italicJCheckBox (lines 54 and 56) and textField (line 59) even though these variables are not declared in the inner class. An inner class has a special relationship with its top-level classthe inner class is allowed to access directly all the instance variables and methods of the top-level class. Method itemStateChanged (line 4661) of class CheckBoxHandler uses this relationship to determine which JCheckBox is the event source, to determine the state of a JCheckBox and to set the font on the JTextField. Notice that none of the code in inner class CheckBoxHandler requires a reference to the top-level class object.

11.9.2. JRadioButton

Radio buttons (declared with class JRadioButton) are similar to check boxes in that they have two statesselected and not selected (also called deselected). However, radio buttons normally appear as a group in which only one button can be selected at a time (see output of Fig. 11.20). Selecting a different radio button forces all others to be deselected. Radio buttons are used to represent mutually exclusive options (i.e., multiple options in the group cannot be selected at the same time). The logical relationship between radio buttons is maintained by a ButtonGroup object (package javax.swing), which itself is not a GUI component. A ButtonGroup object organizes a group of buttons and is not itself displayed in a user interface. Rather, the individual JRadioButton objects from the group are displayed in the GUI.

Common Programming Error 11.3

Adding a ButtonGroup object (or an object of any other class that does not derive from Component) to a container results in a compilation error.

The application of Fig. 11.19 and Fig. 11.20 is similar to that of Fig. 11.17 and Fig. 11.18. The user can alter the font style of a JTextField's text. The application uses radio buttons that permit only a single font style in the group to be selected at a time. Class RadioButtonTest (Fig. 11.20) contains the main method that executes this application.

Figure 11.19. JRadioButtons and ButtonGroups.

(This item is displayed on pages 540 - 541 in the print version)

 1 // Fig. 11.19: RadioButtonFrame.java
 2 // Creating radio buttons using ButtonGroup and JRadioButton.
 3 import java.awt.FlowLayout;
 4 import java.awt.Font;
 5 import java.awt.event.ItemListener;
 6 import java.awt.event.ItemEvent;
 7 import javax.swing.JFrame;
 8 import javax.swing.JTextField;
 9 import javax.swing.JRadioButton;
10 import javax.swing.ButtonGroup;
11
12 public class RadioButtonFrame extends JFrame
13 {
14 private JTextField textField; // used to display font changes
15 private Font plainFont; // font for plain text
16 private Font boldFont; // font for bold text
17 private Font italicFont; // font for italic text
18 private Font boldItalicFont; // font for bold and italic text
19 private JRadioButton plainJRadioButton; // selects plain text 
20 private JRadioButton boldJRadioButton; // selects bold text 
21 private JRadioButton italicJRadioButton; // selects italic text 
22 private JRadioButton boldItalicJRadioButton; // bold and italic 
23 private ButtonGroup radioGroup; // buttongroup to hold radio buttons
24
25 // RadioButtonFrame constructor adds JRadioButtons to JFrame
26 public RadioButtonFrame()
27 {
28 super( "RadioButton Test" );
29 setLayout( new FlowLayout() ); // set frame layout
30
31 textField = new JTextField( "Watch the font style change", 25 );
32 add( textField ); // add textField to JFrame
33
34 // create radio buttons
35 plainJRadioButton = new JRadioButton( "Plain", true ); 
36 boldJRadioButton = new JRadioButton( "Bold", false ); 
37 italicJRadioButton = new JRadioButton( "Italic", false ); 
38 boldItalicJRadioButton = new JRadioButton( "Bold/Italic", false );
39 add( plainJRadioButton ); // add plain button to JFrame
40 add( boldJRadioButton ); // add bold button to JFrame
41 add( italicJRadioButton ); // add italic button to JFrame
42 add( boldItalicJRadioButton ); // add bold and italic button
43
44 // create logical relationship between JRadioButtons 
45 radioGroup = new ButtonGroup(); // create ButtonGroup 
46 radioGroup.add( plainJRadioButton ); // add plain to group 
47 radioGroup.add( boldJRadioButton ); // add bold to group 
48 radioGroup.add( italicJRadioButton ); // add italic to group 
49 radioGroup.add( boldItalicJRadioButton ); // add bold and italic
50
51 // create font objects
52 plainFont = new Font( "Serif", Font.PLAIN, 14 );
53 boldFont = new Font( "Serif", Font.BOLD, 14 );
54 italicFont = new Font( "Serif", Font.ITALIC, 14 );
55 boldItalicFont = new Font( "Serif", Font.BOLD + Font.ITALIC, 14 );
56 textField.setFont( plainFont ); // set initial font to plain
57
58 // register events for JRadioButtons 
59 plainJRadioButton.addItemListener( 
60  new RadioButtonHandler( plainFont ) ); 
61 boldJRadioButton.addItemListener( 
62  new RadioButtonHandler( boldFont ) ); 
63 italicJRadioButton.addItemListener( 
64  new RadioButtonHandler( italicFont ) ); 
65 boldItalicJRadioButton.addItemListener( 
66  new RadioButtonHandler( boldItalicFont ) );
67 } // end RadioButtonFrame constructor
68
69 // private inner class to handle radio button events
70 private class RadioButtonHandler implements ItemListener
71 {
72 private Font font; // font associated with this listener
73
74 public RadioButtonHandler( Font f )
75 {
76 font = f; // set the font of this listener
77 } // end constructor RadioButtonHandler
78
79 // handle radio button events
80 public void itemStateChanged( ItemEvent event )
81 {
82 textField.setFont( font ); // set font of textField
83 } // end method itemStateChanged
84 } // end private inner class RadioButtonHandler
85 } // end class RadioButtonFrame

Figure 11.20. Test class for RadioButtonFrame.

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

 1 // Fig. 11.20: RadioButtonTest.java
 2 // Testing RadioButtonFrame.
 3 import javax.swing.JFrame;
 4
 5 public class RadioButtonTest
 6 {
 7 public static void main( String args[] )
 8 {
 9 RadioButtonFrame radioButtonFrame = new RadioButtonFrame();
10 radioButtonFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
11 radioButtonFrame.setSize( 300, 100 ); // set frame size
12 radioButtonFrame.setVisible( true ); // display frame
13 } // end main
14 } // end class RadioButtonTest

 

Lines 3542 in the constructor (Fig. 11.19) create four JRadioButton objects and add them to the JFrame. Each JRadioButton is created with a constructor call like that in line 35. This constructor specifies the label that appears to the right of the JRadioButton by default and the initial state of the JRadioButton. A TRue second argument indicates that the JRadioButton should appear selected when it is displayed.

Line 45 instantiates ButtonGroup object radioGroup. This object is the "glue" that forms the logical relationship between the four JRadioButton objects and allows only one of the four to be selected at a time. It is possible that no JRadioButtons in a ButtonGroup are selected, but this can only occur if no preselected JRadioButtons are added to the ButtonGroup and the user has not selected a JRadioButton yet. Lines 4649 use ButtonGroup method add to associate each of the JRadioButtons with radioGroup. If more than one selected JRadioButton object is added to the group, the selected one that was added first will be selected when the GUI is displayed.

JRadioButtons, like JCheckBoxes, generate ItemEvents when they are clicked. Lines 5966 create four instances of inner class RadioButtonHandler (declared at lines 7084). In this example, each event listener object is registered to handle the ItemEvent generated when the user clicks a particular JRadioButton. Notice that each RadioButtonHandler object is initialized with a particular Font object (created in lines 5255).

Class RadioButtonHandler (line 7084) implements interface ItemListener so it can handle ItemEvents generated by the JRadioButtons. The constructor stores the Font object it receives as an argument in the event-listener object's instance variable font (declared at line 72). When the user clicks a JRadioButton, radioGroup turns off the previously selected JRadioButton and method itemStateChanged (line 8083) sets the font in the JTextField to the Font stored in the JRadioButton's corresponding event-listener object. Notice that line 82 of inner class RadioButtonHandler uses the top-level class's textField instance variable to set the font.