- •CONTENTS
- •1.1 Introduction
- •1.2 What Is a Computer?
- •1.3 Programs
- •1.4 Operating Systems
- •1.5 Java, World Wide Web, and Beyond
- •1.6 The Java Language Specification, API, JDK, and IDE
- •1.7 A Simple Java Program
- •1.8 Creating, Compiling, and Executing a Java Program
- •1.9 (GUI) Displaying Text in a Message Dialog Box
- •2.1 Introduction
- •2.2 Writing Simple Programs
- •2.3 Reading Input from the Console
- •2.4 Identifiers
- •2.5 Variables
- •2.7 Named Constants
- •2.8 Numeric Data Types and Operations
- •2.9 Problem: Displaying the Current Time
- •2.10 Shorthand Operators
- •2.11 Numeric Type Conversions
- •2.12 Problem: Computing Loan Payments
- •2.13 Character Data Type and Operations
- •2.14 Problem: Counting Monetary Units
- •2.15 The String Type
- •2.16 Programming Style and Documentation
- •2.17 Programming Errors
- •2.18 (GUI) Getting Input from Input Dialogs
- •3.1 Introduction
- •3.2 boolean Data Type
- •3.3 Problem: A Simple Math Learning Tool
- •3.4 if Statements
- •3.5 Problem: Guessing Birthdays
- •3.6 Two-Way if Statements
- •3.7 Nested if Statements
- •3.8 Common Errors in Selection Statements
- •3.9 Problem: An Improved Math Learning Tool
- •3.10 Problem: Computing Body Mass Index
- •3.11 Problem: Computing Taxes
- •3.12 Logical Operators
- •3.13 Problem: Determining Leap Year
- •3.14 Problem: Lottery
- •3.15 switch Statements
- •3.16 Conditional Expressions
- •3.17 Formatting Console Output
- •3.18 Operator Precedence and Associativity
- •3.19 (GUI) Confirmation Dialogs
- •4.1 Introduction
- •4.2 The while Loop
- •4.3 The do-while Loop
- •4.4 The for Loop
- •4.5 Which Loop to Use?
- •4.6 Nested Loops
- •4.7 Minimizing Numeric Errors
- •4.8 Case Studies
- •4.9 Keywords break and continue
- •4.10 (GUI) Controlling a Loop with a Confirmation Dialog
- •5.1 Introduction
- •5.2 Defining a Method
- •5.3 Calling a Method
- •5.4 void Method Example
- •5.5 Passing Parameters by Values
- •5.6 Modularizing Code
- •5.7 Problem: Converting Decimals to Hexadecimals
- •5.8 Overloading Methods
- •5.9 The Scope of Variables
- •5.10 The Math Class
- •5.11 Case Study: Generating Random Characters
- •5.12 Method Abstraction and Stepwise Refinement
- •6.1 Introduction
- •6.2 Array Basics
- •6.3 Problem: Lotto Numbers
- •6.4 Problem: Deck of Cards
- •6.5 Copying Arrays
- •6.6 Passing Arrays to Methods
- •6.7 Returning an Array from a Method
- •6.8 Variable-Length Argument Lists
- •6.9 Searching Arrays
- •6.10 Sorting Arrays
- •6.11 The Arrays Class
- •7.1 Introduction
- •7.2 Two-Dimensional Array Basics
- •7.3 Processing Two-Dimensional Arrays
- •7.4 Passing Two-Dimensional Arrays to Methods
- •7.5 Problem: Grading a Multiple-Choice Test
- •7.6 Problem: Finding a Closest Pair
- •7.7 Problem: Sudoku
- •7.8 Multidimensional Arrays
- •8.1 Introduction
- •8.2 Defining Classes for Objects
- •8.3 Example: Defining Classes and Creating Objects
- •8.4 Constructing Objects Using Constructors
- •8.5 Accessing Objects via Reference Variables
- •8.6 Using Classes from the Java Library
- •8.7 Static Variables, Constants, and Methods
- •8.8 Visibility Modifiers
- •8.9 Data Field Encapsulation
- •8.10 Passing Objects to Methods
- •8.11 Array of Objects
- •9.1 Introduction
- •9.2 The String Class
- •9.3 The Character Class
- •9.4 The StringBuilder/StringBuffer Class
- •9.5 Command-Line Arguments
- •9.6 The File Class
- •9.7 File Input and Output
- •9.8 (GUI) File Dialogs
- •10.1 Introduction
- •10.2 Immutable Objects and Classes
- •10.3 The Scope of Variables
- •10.4 The this Reference
- •10.5 Class Abstraction and Encapsulation
- •10.6 Object-Oriented Thinking
- •10.7 Object Composition
- •10.8 Designing the Course Class
- •10.9 Designing a Class for Stacks
- •10.10 Designing the GuessDate Class
- •10.11 Class Design Guidelines
- •11.1 Introduction
- •11.2 Superclasses and Subclasses
- •11.3 Using the super Keyword
- •11.4 Overriding Methods
- •11.5 Overriding vs. Overloading
- •11.6 The Object Class and Its toString() Method
- •11.7 Polymorphism
- •11.8 Dynamic Binding
- •11.9 Casting Objects and the instanceof Operator
- •11.11 The ArrayList Class
- •11.12 A Custom Stack Class
- •11.13 The protected Data and Methods
- •11.14 Preventing Extending and Overriding
- •12.1 Introduction
- •12.2 Swing vs. AWT
- •12.3 The Java GUI API
- •12.4 Frames
- •12.5 Layout Managers
- •12.6 Using Panels as Subcontainers
- •12.7 The Color Class
- •12.8 The Font Class
- •12.9 Common Features of Swing GUI Components
- •12.10 Image Icons
- •13.1 Introduction
- •13.2 Exception-Handling Overview
- •13.3 Exception-Handling Advantages
- •13.4 Exception Types
- •13.5 More on Exception Handling
- •13.6 The finally Clause
- •13.7 When to Use Exceptions
- •13.8 Rethrowing Exceptions
- •13.9 Chained Exceptions
- •13.10 Creating Custom Exception Classes
- •14.1 Introduction
- •14.2 Abstract Classes
- •14.3 Example: Calendar and GregorianCalendar
- •14.4 Interfaces
- •14.5 Example: The Comparable Interface
- •14.6 Example: The ActionListener Interface
- •14.7 Example: The Cloneable Interface
- •14.8 Interfaces vs. Abstract Classes
- •14.9 Processing Primitive Data Type Values as Objects
- •14.10 Sorting an Array of Objects
- •14.11 Automatic Conversion between Primitive Types and Wrapper Class Types
- •14.12 The BigInteger and BigDecimal Classes
- •14.13 Case Study: The Rational Class
- •15.1 Introduction
- •15.2 Graphical Coordinate Systems
- •15.3 The Graphics Class
- •15.4 Drawing Strings, Lines, Rectangles, and Ovals
- •15.5 Case Study: The FigurePanel Class
- •15.6 Drawing Arcs
- •15.7 Drawing Polygons and Polylines
- •15.8 Centering a String Using the FontMetrics Class
- •15.9 Case Study: The MessagePanel Class
- •15.10 Case Study: The StillClock Class
- •15.11 Displaying Images
- •15.12 Case Study: The ImageViewer Class
- •16.1 Introduction
- •16.2 Event and Event Source
- •16.3 Listeners, Registrations, and Handling Events
- •16.4 Inner Classes
- •16.5 Anonymous Class Listeners
- •16.6 Alternative Ways of Defining Listener Classes
- •16.7 Problem: Loan Calculator
- •16.8 Window Events
- •16.9 Listener Interface Adapters
- •16.10 Mouse Events
- •16.11 Key Events
- •16.12 Animation Using the Timer Class
- •17.1 Introduction
- •17.2 Buttons
- •17.3 Check Boxes
- •17.4 Radio Buttons
- •17.5 Labels
- •17.6 Text Fields
- •17.7 Text Areas
- •17.8 Combo Boxes
- •17.9 Lists
- •17.10 Scroll Bars
- •17.11 Sliders
- •17.12 Creating Multiple Windows
- •18.1 Introduction
- •18.2 Developing Applets
- •18.3 The HTML File and the <applet> Tag
- •18.4 Applet Security Restrictions
- •18.5 Enabling Applets to Run as Applications
- •18.6 Applet Life-Cycle Methods
- •18.7 Passing Strings to Applets
- •18.8 Case Study: Bouncing Ball
- •18.9 Case Study: TicTacToe
- •18.10 Locating Resources Using the URL Class
- •18.11 Playing Audio in Any Java Program
- •18.12 Case Study: Multimedia Animations
- •19.1 Introduction
- •19.2 How is I/O Handled in Java?
- •19.3 Text I/O vs. Binary I/O
- •19.4 Binary I/O Classes
- •19.5 Problem: Copying Files
- •19.6 Object I/O
- •19.7 Random-Access Files
- •20.1 Introduction
- •20.2 Problem: Computing Factorials
- •20.3 Problem: Computing Fibonacci Numbers
- •20.4 Problem Solving Using Recursion
- •20.5 Recursive Helper Methods
- •20.6 Problem: Finding the Directory Size
- •20.7 Problem: Towers of Hanoi
- •20.8 Problem: Fractals
- •20.9 Problem: Eight Queens
- •20.10 Recursion vs. Iteration
- •20.11 Tail Recursion
- •APPENDIXES
- •INDEX
578 Chapter 17 |
Creating Graphical User Interfaces |
|
Each button has a tool tip text (lines 44–45), which appears when the mouse is set on the |
|
button without being clicked, as shown in Figure 17.10(c). |
|
Note |
locating MessagePanel |
Since MessagePanel is not in the Java API, you should place MessagePanel.java in the same |
|
directory with ButtonDemo.java. |
toggle button
Video Note
Use check boxes
17.3 Check Boxes
A toggle button is a two-state button like a light switch. JToggleButton inherits AbstractButton and implements a toggle button. Often JToggleButton's subclasses JCheckBox and JRadioButton are used to enable the user to toggle a choice on or off. This section introduces JCheckBox. JRadioButton will be introduced in the next section.
JCheckBox inherits all the properties from AbstractButton, such as text, icon, mnemonic, verticalAlignment, horizontalAlignment, horizontalTextPosition, verticalTextPosition, and selected, and provides several constructors to create check boxes, as shown in Figure 17.11.
Adds an ActionListener for this object.
Adds an ItemListener for this object.
FIGURE 17.11 JCheckBox defines a check box button.
Here is an example of a check box with text Student, foreground red, background white, mnemonic key 'S', and initially selected.
JCheckBox jchk = new JCheckBox("Student", true); jchk.setForeground(Color.RED); jchk.setBackground(Color.WHITE); jchk.setMnemonic('S');
When a check box is clicked (checked or unchecked), it fires an ItemEvent and then an ActionEvent. To see if a check box is selected, use the isSelected() method.
Listing 17.3 gives a program that adds three check boxes named Centered, Bold, and Italic to the preceding example to let the user specify whether the message is centered, bold, or italic, as shown in Figure 17.12.
17.3 Check Boxes 579
JPanel with GridLayout for three check boxes
FIGURE 17.12 Three check boxes are added to specify how the message is displayed.
There are at least two approaches to writing this program. The first is to revise the preceding ButtonDemo class to insert the code for adding the check boxes and processing their events. The second is to create a subclass that extends ButtonDemo. Please implement the first approach as an exercise. Listing 17.3 gives the code to implement the second approach.
LISTING 17.3 CheckBoxDemo.java
1 import java.awt.*;
2 import java.awt.event.*;
3 import javax.swing.*;
4
5 public class CheckBoxDemo extends ButtonDemo {
6 // Create three check boxes to control the display of message 7 private JCheckBox jchkCentered = new JCheckBox("Centered");
8private JCheckBox jchkBold = new JCheckBox("Bold");
9 private JCheckBox jchkItalic = new JCheckBox("Italic");
10
11public static void main(String[] args) {
12CheckBoxDemo frame = new CheckBoxDemo();
13frame.setTitle("CheckBoxDemo");
14frame.setSize(500, 200);
15frame.setLocationRelativeTo(null); // Center the frame
16frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
17frame.setVisible(true);
18}
19
20public CheckBoxDemo() {
21// Set mnemonic keys
22jchkCentered.setMnemonic('C');
23jchkBold.setMnemonic('B');
24jchkItalic.setMnemonic('I');
26// Create a new panel to hold check boxes
27JPanel jpCheckBoxes = new JPanel();
28jpCheckBoxes.setLayout(new GridLayout(3, 1));
29jpCheckBoxes.add(jchkCentered);
30jpCheckBoxes.add(jchkBold);
31jpCheckBoxes.add(jchkItalic);
32add(jpCheckBoxes, BorderLayout.EAST);
34// Register listeners with the check boxes
35jchkCentered.addActionListener(new ActionListener() {
36public void actionPerformed(ActionEvent e) {
37messagePanel.setCentered(jchkCentered.isSelected());
38}
39});
40jchkBold.addActionListener(new ActionListener() {
JFrame
ButtonDemo
CheckBoxDemo
create frame
create UI
register listener
register listener
580 Chapter 17 |
Creating Graphical User Interfaces |
|||||
|
41 |
|
|
public void actionPerformed(ActionEvent e) { |
||
|
42 |
|
|
setNewFont(); |
||
|
43 |
} |
|
|
||
|
44 |
}); |
|
|
||
|
45 |
|
|
jchkItalic.addActionListener(new ActionListener() { |
|
|
|
46 |
|
|
public void actionPerformed(ActionEvent e) { |
||
|
47 |
|
|
setNewFont(); |
||
|
48 |
} |
|
|
||
|
49 |
}); |
|
|
||
|
50 |
} |
|
|
|
|
|
51 |
|
|
|
|
|
set a new font |
52 |
|
private void setNewFont() { |
|
|
|
|
53 |
|
|
// Determine a font style |
||
|
54 |
|
|
int fontStyle = Font.PLAIN; |
||
|
55 |
|
|
fontStyle += (jchkBold.isSelected() ? Font.BOLD : Font.PLAIN); |
||
|
56 |
|
fontStyle += (jchkItalic.isSelected() ? Font.ITALIC : Font.PLAIN); |
|||
|
57 |
|
|
|
|
|
|
58 |
|
|
// Set font for the message |
||
|
59 |
|
|
Font font = messagePanel.getFont(); |
||
|
60 |
|
|
messagePanel.setFont( |
||
|
61 |
|
|
new Font(font.getName(), fontStyle, font.getSize())); |
||
|
62 |
} |
|
|
|
|
|
63 |
} |
|
|
|
|
CheckBoxDemo extends ButtonDemo and adds three check boxes to control how the message is displayed. When a CheckBoxDemo is constructed (line 12), its superclass’s no-arg constructor is invoked, so you don’t have to rewrite the code that is already in the constructor of ButtonDemo.
When a check box is checked or unchecked, the listener’s actionPerformed method is invoked to process the event. When the Centered check box is checked or unchecked, the centered property of the MessagePanel class is set to true or false.
The current font name and size used in MessagePanel are obtained from messagePanel.getFont() using the getName() and getSize() methods. The font styles (Font.BOLD and Font.ITALIC) are specified in the check boxes. If no font style is selected, the font style is Font.PLAIN. Font styles are combined by adding together the selected integers representing the fonts.
The keyboard mnemonics C, B, and I are set on the check boxes Centered, Bold, and Italic, respectively (lines 22–24). You can use a mouse click or a shortcut key to select a check box.
The setFont method (line 60) defined in the Component class is inherited in the MessagePanel class. This method automatically invokes the repaint method. Invoking setFont in messagePanel automatically repaints the message.
A check box fires an ActionEvent and an ItemEvent when it is clicked. You could process either the ActionEvent or the ItemEvent to redisplay the message. The example processes the ActionEvent. If you wish to process the ItemEvent, create a listener for ItemEvent and register it with a check box. The listener must implement the itemStateChanged handler to process an ItemEvent. For example, the following code registers an ItemListener with jchkCentered:
// To listen for ItemEvent jchkCentered.addItemListener(new ItemListener() {
/** Handle ItemEvent */
public void itemStateChanged(ItemEvent e) { messagePanel.setCentered(jchkCentered.isSelected());
}
});
17.4 Radio Buttons 581
17.4 Radio Buttons
Radio buttons, also known as option buttons, enable you to choose a single item from a group of choices. In appearance radio buttons resemble check boxes, but check boxes display a square that is either checked or blank, whereas radio buttons display a circle that is either filled (if selected) or blank (if not selected).
JRadioButton inherits AbstractButton and provides several constructors to create radio buttons, as shown in Figure 17.13. These constructors are similar to the constructors for
JCheckBox.
Video Note
Use radio buttons
javax.swing.AbstractButton |
|
|
|
|
|
|
|
|
javax.swing.JToggleButton |
|
|
|
|
|
|
|
|
javax.swing.JRadioButton |
|
|
|
|
|
+JRadioButton() |
|
Creates a default radio button with no text and icon. |
+JRadioButton(text: String) |
|
Creates a radio button with text. |
+JRadioButton(text: String, selected: |
|
Creates a radio button with text and specifies whether the radio button is |
boolean) |
|
initially selected. |
+JRadioButton(icon: Icon) |
|
Creates a radio button with an icon. |
+JRadioButton(text: String, icon: Icon) |
|
Creates a radio button with text and an icon. |
+JRadioButton(text: String, icon: Icon, |
|
Creates a radio button with text and an icon, and specifies whether the |
selected: boolean) |
|
radio button is initially selected. |
+addActionEvent(listener: |
|
Adds an ActionListener for this object. |
ActionListener): void |
|
|
+addItemListener(listener: ItemListener) |
|
Adds an ItemListener for this object. |
: void |
|
|
|
|
|
FIGURE 17.13 JRadioButton defines a radio button.
Here is an example of a radio button with text Student, red foreground, white background, mnemonic key S, and initially selected.
JRadioButton jrb = new JRadioButton("Student", true); jrb.setForeground(Color.RED); jrb.setBackground(Color.WHITE);
jrb.setMnemonic('S');
To group radio buttons, you need to create an instance of java.swing.ButtonGroup and use the add method to add them to it, as follows:
ButtonGroup group = new ButtonGroup(); group.add(jrb1);
group.add(jrb2);
This code creates a radio-button group for radio buttons jrb1 and jrb2 so that they are selected mutually exclusively. Without grouping, jrb1 and jrb2 would be independent.
582 Chapter 17 |
Creating Graphical User Interfaces |
|
Note |
GUI helper class |
ButtonGroup is not a subclass of java.awt.Component, so a ButtonGroup object can- |
|
not be added to a container. |
|
When a radio button is changed (selected or deselected), it fires an ItemEvent and then an |
|
ActionEvent. To see if a radio button is selected, use the isSelected() method. |
|
Listing 17.4 gives a program that adds three radio buttons named Red, Green, and Blue |
|
to the preceding example to let the user choose the color of the message, as shown in |
|
Figure 17.14. |
JPanel with GridLayout for three
radio buttons
FIGURE 17.14 Three radio buttons are added to specify the color of the message.
Again there are at least two approaches to writing this program. The first is to revise the preceding CheckBoxDemo class to insert the code for adding the radio buttons and processing their events. The second is to create a subclass that extends CheckBoxDemo. Listing 17.4 gives the code to implement the second approach.
LISTING 17.4 RadioButtonDemo.java
|
1 |
import java.awt.*; |
|
JFrame |
|||||
|
2 |
import java.awt.event.*; |
|
|
|||||
|
3 |
import javax.swing.*; |
|
|
|||||
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ButtonDemo |
|
|
5 |
public class |
RadioButtonDemo extends CheckBoxDemo |
{ |
|
|
|||
|
6 |
|
// Declare radio buttons |
|
|
||||
|
7 |
|
private JRadioButton jrbRed, jrbGreen, jrbBlue; |
|
|
|
|||
|
|
|
|
CheckBoxDemo |
|||||
|
8 |
|
public static void main(String[] args) { |
|
|
||||
|
9 |
|
|
|
|||||
create frame |
10 |
|
RadioButtonDemo frame = new RadioButtonDemo(); |
|
|||||
|
RadioButtonDemo |
||||||||
|
11 |
|
frame.setSize(500, 200); |
|
|
||||
|
12 |
|
frame.setLocationRelativeTo(null); // Center the frame |
||||||
|
13 |
|
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); |
||||||
|
14 |
|
frame.setTitle("RadioButtonDemo"); |
|
|
||||
|
15 |
|
frame.setVisible(true); |
|
|
||||
|
16 |
} |
|
|
|
|
|
|
|
|
17 |
|
|
|
|
|
|
|
|
create UI |
18 |
|
public RadioButtonDemo() { |
|
|
||||
|
19 |
|
// Create a new panel to hold check boxes |
|
|
||||
|
20 |
|
JPanel jpRadioButtons = new JPanel(); |
|
|
||||
|
21 |
|
jpRadioButtons.setLayout(new GridLayout(3, 1)); |
|
|
||||
|
22 |
|
jpRadioButtons.add(jrbRed |
= new JRadioButton("Red") |
); |
||||
|
23 |
|
jpRadioButtons.add(jrbGreen = new JRadioButton("Green")); |
||||||
|
24 |
|
jpRadioButtons.add(jrbBlue = new JRadioButton("Blue")); |