- •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
274 Chapter 8 Objects and Classes
|
|
|
|
|
|
Object type assignment c1 = c2 |
|
|
|||||||||||
Before: |
|
|
|
|
After: |
|
|
||||||||||||
|
|
|
|
|
|
|
|
c1 |
|
|
|
|
|
|
|
|
|
||
c1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||
|
|
|
|
|
|
|
|
c2 |
|
|
|
|
|
|
|
|
|
||
c2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
c2: Circle |
|
|
c1: Circle |
|
|
|
c2: Circle |
c1: Circle |
||||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||||
|
|
|
radius = 9 |
|
|
radius = 5 |
|
|
|
radius = 9 |
|
radius = 5 |
|||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FIGURE 8.8 Reference variable c2 is copied to variable c1.
|
Note |
|
As shown in Figure 8.8, after the assignment statement c1 = c2, c1 points to the same object |
|
referenced by c2. The object previously referenced by c1 is no longer useful and therefore is now |
garbage |
known as garbage. Garbage occupies memory space. The Java runtime system detects garbage |
garbage collection |
and automatically reclaims the space it occupies. This process is called garbage collection. |
Tip
If you know that an object is no longer needed, you can explicitly assign null to a reference variable for the object. The JVM will automatically collect the space if the object is not referenced by any reference variable.
|
|
|
|
8.6 |
Using Classes from the Java Library |
|||
|
|
|
|
Listing 8.1 defined the Circle1 class and created objects from the class. You will frequently |
||||
|
|
|
|
use the classes in the Java library to develop programs. This section gives some examples of |
||||
|
|
|
|
the classes in the Java library. |
|
|
|
|
|
|
|
|
8.6.1 |
The Date Class |
|
|
|
|
|
|
|
In Listing 2.8, ShowCurrentTime.java, you learned how to obtain the current time using |
||||
|
|
|
|
System.currentTimeMillis(). You used the division and remainder operators to extract |
||||
|
|
|
|
current second, minute, and hour. Java provides a system-independent encapsulation of date |
||||
java.util.Date class |
and time in the java.util.Date class, as shown in Figure 8.9. |
|||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
java.util.Date |
|
|
|
The + sign indicates |
|
+Date() |
|
Constructs a Date object for the current time. |
|
|||
+Date(elapseTime: long) |
|
|
|
|||||
public modifier |
|
|
|
Constructs a Date object for a given time in |
|
|||
|
||||||||
|
|
|
|
|
|
|
milliseconds elapsed since January 1, 1970, GMT. |
|
|
|
|
|
+toString(): String |
|
Returns a string representing the date and time. |
|
|
|
|
|
|
+getTime(): long |
|
Returns the number of milliseconds since January 1, |
|
|
|
|
|
|
|
|
|
1970, GMT. |
|
|
|
|
|
+setTime(elapseTime: long): void |
|
Sets a new elapse time in the object. |
|
|
|
|
|
|
|
|
|
|
|
FIGURE 8.9 A Date object represents a specific date and time.
You can use the no-arg constructor in the Date class to create an instance for the current date and time, its getTime() method to return the elapsed time since January 1, 1970, GMT, and its toString method to return the date and time as a string. For example, the following code
8.6 Using Classes from the Java Library 275
java.util.Date date = new java.util.Date() ; System.out.println("The elapsed time since Jan 1, 1970 is " +
date.getTime() + " milliseconds"); System.out.println(date.toString() );
create object
get elapsed time invoke toString
displays the output like this:
The elapsed time since Jan 1, 1970 is 1100547210284 milliseconds Mon Nov 15 14:33:30 EST 2004
The Date class has another constructor, Date(long elapseTime), which can be used to construct a Date object for a given time in milliseconds elapsed since January 1, 1970, GMT.
8.6.2The Random Class
You have used Math.random() to obtain a random double value between 0.0 and 1.0 (excluding 1.0). Another way to generate random numbers is to use the java.util.Random class, as shown in Figure 8.10, which can generate a random int, long, double, float, and boolean value.
java.util.Random |
|
|
+Random() |
|
Constructs a Random object with the current time as its seed. |
+Random(seed: long) |
|
Constructs a Random object with a specified seed. |
+nextInt(): int |
|
Returns a random int value. |
+nextInt(n: int): int |
|
Returns a random int value between 0 and n (exclusive). |
+nextLong(): long |
|
Returns a random long value. |
+nextDouble(): double |
|
Returns a random double value between 0.0 and 1.0 (exclusive). |
+nextFloat(): float |
|
Returns a random float value between 0.0F and 1.0F (exclusive). |
+nextBoolean(): boolean |
|
Returns a random boolean value. |
|
|
|
FIGURE 8.10 A Random object can be used to generate random values.
When you create a Random object, you have to specify a seed or use the default seed. The no-arg constructor creates a Random object using the current elapsed time as its seed. If two Random objects have the same seed, they will generate identical sequences of numbers. For example, the following code creates two Random objects with the same seed, 3.
Random random1 = new Random(3); System.out.print("From random1: "); for (int i = 0; i < 10; i++)
System.out.print(random1.nextInt(1000) + " ");
Random random2 = new Random(3); System.out.print("\nFrom random2: "); for (int i = 0; i < 10; i++)
System.out.print(random2.nextInt(1000) + " ");
The code generates the same sequence of random int values:
From random1: 734 660 210 581 128 202 549 564 459 961
From random2: 734 660 210 581 128 202 549 564 459 961
Note
The ability to generate the same sequence of random values is useful in software testing and |
same sequence |
many other applications. In software testing, you can test your program using a fixed sequence of |
|
numbers before using different sequences of random numbers. |
|
276Chapter 8 Objects and Classes
8.6.3Displaying GUI Components
Pedagogical Note
Graphical user interface (GUI) components are good examples for teaching OOP. Simple GUI examples are introduced for this purpose. The full introduction to GUI programming begins with Chapter 12, “GUI Basics.”
When you develop programs to create graphical user interfaces, you will use Java classes such as JFrame, JButton, JRadioButton, JComboBox, and JList to create frames, buttons, radio buttons, combo boxes, lists, and so on. Listing 8.5 is an example that creates two windows using the JFrame class. The output of the program is shown in Figure 8.11.
FIGURE 8.11 The program creates two windows using the JFrame class.
LISTING 8.5 TestFrame.java
|
1 |
import javax.swing.JFrame; |
|||
|
2 |
|
|
|
|
|
3 |
public class TestFrame { |
|||
|
4 |
public static void main(String[] args) { |
|||
create an object |
5 |
|
JFrame frame1 = new JFrame(); |
|
|
invoke a method |
6 |
|
frame1.setTitle("Window 1"); |
||
|
7 |
|
frame1.setSize(200, 150); |
||
|
8 |
|
frame1.setLocation(200, 100); |
||
|
9 |
|
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); |
||
|
10 |
|
frame1.setVisible(true); |
||
|
11 |
|
|
|
|
create an object |
12 |
|
JFrame frame2 = new JFrame(); |
|
|
invoke a method |
13 |
|
frame2.setTitle("Window 2"); |
||
|
14 |
|
frame2.setSize(200, 150); |
||
|
15 |
|
frame2.setLocation(410, 100); |
||
|
16 |
|
frame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); |
||
|
17 |
|
frame2.setVisible(true); |
||
|
18 |
} |
|
|
|
|
19 |
} |
|
|
|
This program creates two objects of the JFrame class (lines 5, 12) and then uses the methods setTitle, setSize, setLocation, setDefaultCloseOperation, and setVisible to set the properties of the objects. The setTitle method sets a title for the window (lines 6, 13). The setSize method sets the window’s width and height (lines 7, 14). The setLocation method specifies the location of the window’s upper-left corner (lines 8, 15). The setDefaultCloseOperation method terminates the program when the frame is closed (lines 9, 16). The setVisible method displays the window.
You can add graphical user interface components, such as buttons, labels, text fields, check boxes, and combo boxes to the window. The components are defined using classes. Listing 8.6 gives an example of creating a graphical user interface, as shown in Figure 8.1.
8.6 Using Classes from the Java Library 277
LISTING 8.6 GUIComponents.java
1 import javax.swing.*;
2
3 public class GUIComponents {
4 public static void main(String[] args) {
5// Create a button with text OK
6 JButton jbtOK = new JButton("OK");
7
8// Create a button with text Cancel
9 JButton jbtCancel = new JButton("Cancel");
10
11// Create a label with text "Enter your name: "
12JLabel jlblName = new JLabel("Enter your name: ");
14// Create a text field with text "Type Name Here"
15JTextField jtfName = new JTextField("Type Name Here");
17// Create a check box with text bold
18JCheckBox jchkBold = new JCheckBox("Bold");
20// Create a check box with text italic
21JCheckBox jchkItalic = new JCheckBox("Italic");
23// Create a radio button with text red
24JRadioButton jrbRed = new JRadioButton("Red");
26// Create a radio button with text yellow
27JRadioButton jrbYellow = new JRadioButton("Yellow");
29// Create a combo box with several choices
30JComboBox jcboColor = new JComboBox(new String[]{"Freshman",
31"Sophomore", "Junior", "Senior"});
33// Create a panel to group components
34JPanel panel = new JPanel();
35panel.add(jbtOK); // Add the OK button to the panel
36panel.add(jbtCancel); // Add the Cancel button to the panel
37panel.add(jlblName); // Add the label to the panel
38panel.add(jtfName); // Add the text field to the panel
39panel.add(jchkBold); // Add the check box to the panel
40panel.add(jchkItalic); // Add the check box to the panel
41panel.add(jrbRed); // Add the radio button to the panel
42panel.add(jrbYellow); // Add the radio button to the panel
43panel.add(jcboColor); // Add the combo box to the panel
45JFrame frame = new JFrame(); // Create a frame
46frame.add(panel); // Add the panel to the frame
47frame.setTitle("Show GUI Components");
48frame.setSize(450, 100);
49frame.setLocation(200, 100);
50frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
51frame.setVisible(true);
52}
53}
Video Note
Use classes
create a button
create a button
create a label
create a text field
create a check box
create a check box
create a radio button
create a radio button
create a combo box
create a panel add to panel
create a frame add panel to frame
display frame
This program creates GUI objects using the classes JButton, JLabel, JTextField,
JCheckBox, JRadioButton, and JComboBox (lines 6–31). Then, using the JPanel class (line 34), it then creates a panel object and adds to it the button, label, text field, check box,