- •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
10.8 Designing the Course Class 355
private Person supervisor;
...
}
If a person may have several supervisors, as shown in Figure 10.8(a), you may use an array to store supervisors, as shown in Figure 10.8(b).
|
|
1 |
|
public class Person { |
||||
Person |
||||||||
|
|
|
||||||
|
|
|
|
|
... |
|
||
m |
|
|
|
Supervisor |
} |
private Person[] supervisors; |
|
|
|
|
|
|
|
|
|||
|
|
|
|
|
|
|
||
|
|
|
|
|
|
|
|
|
|
|
(a) |
|
(b) |
FIGURE 10.8 A person may have several supervisors.
Note
Since aggregation and composition relationships are represented using classes in similar ways, |
aggregation or composition |
many texts don’t differentiate them and call both compositions. |
|
10.8 Designing the Course Class
This book’s philosophy is teaching by example and learning by doing. The book provides a wide variety of examples to demonstrate object-oriented programming. The next three sections offer additional examples on designing classes.
Suppose you need to process course information. Each course has a name and has students enrolled. You should be able to add/drop a student to/from the course. You can use a class to model the courses, as shown in Figure 10.9.
Course
-courseName: String -students: String[] -numberOfStudents: int
+Course(courseName: String) +getCourseName(): String +addStudent(student: String): void +dropStudent(student: String): void +getStudents(): String[] +getNumberOfStudents(): int
The name of the course.
An array to store the students for the course. The number of students (default: 0).
Creates a course with the specified name. Returns the course name.
Adds a new student to the course. Drops a student from the course. Returns the students for the course.
Returns the number of students for the course.
FIGURE 10.9 The Course class models the courses.
A Course object can be created using the constructor Course(String name) by passing a course name. You can add students to the course using the addStudent(String student) method, drop a student from the course using the dropStudent(String student) method, and return all the students for the course using the getStudents() method. Suppose the class is available; Listing 10.5 gives a test class that creates two courses and adds students to them.
356 Chapter 10 |
|
Thinking in Objects |
|
|
|
|
|
|
|
|
|
|
|
|||||||
|
|
|
|
|
LISTING 10.5 |
TestCourse.java |
||||||||||||||
|
1 |
public class TestCourse { |
||||||||||||||||||
|
2 |
|
public static void main(String[] args) { |
|||||||||||||||||
create a course |
3 |
|
|
Course course1 = new Course("Data Structures"); |
|
|||||||||||||||
|
4 |
|
|
Course course2 = new Course("Database Systems"); |
|
|||||||||||||||
|
5 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||
add a student |
6 |
|
|
course1.addStudent("Peter Jones"); |
|
|
|
|
|
|||||||||||
|
7 |
|
|
course1.addStudent("Brian Smith"); |
||||||||||||||||
|
8 |
|
|
course1.addStudent("Anne Kennedy"); |
||||||||||||||||
|
9 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||
|
10 |
|
|
course2.addStudent("Peter Jones"); |
|
|
|
|
|
|||||||||||
|
11 |
|
|
course2.addStudent("Steve Smith"); |
||||||||||||||||
|
12 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||
|
13 |
|
|
System.out.println("Number of students in course1: " |
||||||||||||||||
number of students |
14 |
+ |
course1.getNumberOfStudents() |
); |
|
|
|
|
||||||||||||
return students |
15 |
|
|
String[] students = |
course1.getStudents() |
; |
|
|
||||||||||||
|
16 |
|
|
for (int i = 0; i < |
course1.getNumberOfStudents() |
; i++) |
||||||||||||||
|
17 |
|
|
System.out.print(students[i] + ", "); |
||||||||||||||||
|
18 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||
|
19 |
|
System.out.println(); |
|||||||||||||||||
|
20 |
|
System.out.print("Number of students in course2: " |
|||||||||||||||||
|
21 |
|
|
+ course2.getNumberOfStudents()); |
||||||||||||||||
|
22 |
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|||||
|
23 |
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||
|
|
|
|
|
|
|
|
|
|
|
||||||||||
|
|
|
|
|
Number of students in course1: 3 |
|||||||||||||||
|
|
|
|
|
Peter Jones, Brian Smith, Anne Kennedy, |
|||||||||||||||
|
|
|
|
|||||||||||||||||
|
|
|
|
|
Number of students in course2: 2 |
|||||||||||||||
|
|
|
|
|
|
|
|
|
|
|
||||||||||
|
|
|
|
|
The Course class is implemented in Listing 10.6. It uses an array to store the students for the |
|||||||||||||||
|
|
|
|
|
course. For simplicity, assume that the maximum course enrollment is 100. The array is cre- |
|||||||||||||||
|
|
|
|
|
ated using new String[100] in line 3. The addStudent method (line 10) adds a student to |
|||||||||||||||
|
|
|
|
|
the array. Whenever a new student is added to the course, numberOfStudents is increased |
|||||||||||||||
|
|
|
|
|
(line 12). The getStudents method returns the array. The dropStudent method (line 27) |
|||||||||||||||
|
|
|
|
is left as an exercise. |
||||||||||||||||
|
|
|
|
|
LISTING 10.6 |
Course.java |
||||||||||||||
|
1 |
public class Course { |
||||||||||||||||||
|
2 |
|
private String courseName; |
|||||||||||||||||
create students |
3 |
|
private String[] students = |
new String[100]; |
||||||||||||||||
|
4 |
|
private int numberOfStudents; |
|||||||||||||||||
|
5 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||
add a course |
6 |
|
public Course(String courseName) { |
|||||||||||||||||
|
7 |
|
|
this.courseName = courseName; |
||||||||||||||||
|
8 |
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|||||
|
9 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||
|
10 |
|
public void addStudent(String student) { |
|
|
|||||||||||||||
|
11 |
|
|
students[numberOfStudents] = student; |
||||||||||||||||
|
12 |
|
|
numberOfStudents++; |
||||||||||||||||
|
13 |
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|||||
|
14 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||||
return students |
15 |
|
public String[] getStudents() { |
|
|
|
||||||||||||||
|
16 |
|
|
return students; |
||||||||||||||||
|
17 |
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|||||
|
18 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
10.9 |
Designing a Class for Stacks 357 |
|
|
|
|
|
19 |
public int getNumberOfStudents() { |
|
number of students |
20 |
return numberOfStudents; |
|
|
21 |
} |
|
|
22 |
|
|
|
23public String getCourseName() {
24return courseName;
25}
26
27public void dropStudent(String student) {
28// Left as an exercise in Exercise 10.9
29}
30}
The array size is fixed to be 100 (line 3) in Listing 10.6. You can improve it to automatically increase the array size in Exercise 10.9.
When you create a Course object, an array object is created. A Course object contains a reference to the array. For simplicity, you can say that the Course object contains the array.
The user can create a Course and manipulate it through the public methods addStudent, dropStudent, getNumberOfStudents, and getStudents. However, the user doesn’t need to know how these methods are implemented. The Course class encapsulates the internal implementation. This example uses an array to store students. You may use a different data structure to store students. The program that uses Course does not need to change as long as the contract of the public methods remains unchanged.
10.9 Designing a Class for Stacks
Recall that a stack is a data structure that holds data in a last-in, first-out fashion, as shown in Figure 10.10.
Data1 |
Data2 |
|
Data3 |
|
|
|
|
|
Data3 |
|
|
|
Data2 |
Data2 |
|
|
Data1 |
Data1 |
Data1 |
Data3 |
Data2 |
|
Data1 |
|
|
|
|
||
|
Data2 |
Data1 |
|
|
|
Data1 |
|
|
FIGURE 10.10 A stack holds data in a last-in, first-out fashion.
Stacks have many applications. For example, the compiler uses a stack to process method invocations. When a method is invoked, its parameters and local variables are pushed into a stack. When a method calls another method, the new method’s parameters and local variables are pushed into the stack. When a method finishes its work and returns to its caller, its associated space is released from the stack.
You can define a class to model stacks. For simplicity, assume the stack holds the int values. So, name the stack class StackOfIntegers. The UML diagram for the class is shown in Figure 10.11.
Suppose that the class is available. Let us write a test program in Listing 10.7 that uses the class to create a stack (line 3), stores ten integers 0, 1, 2, Á , and 9 (line 6), and displays them in reverse order (line 9).
stack
Video Note
The StackOfInteger class
358 Chapter 10 Thinking in Objects
create a stack
push to stack
pop from stack
FIGURE 10.11 The StackOfIntegers class encapsulates the stack storage and provides the operations for manipulating the stack.
LISTING 10.7 TestStackOfIntegers.java
1 public class TestStackOfIntegers {
2public static void main(String[] args) {
3 StackOfIntegers stack = new StackOfIntegers();
4
5for (int i = 0; i < 10; i++)
6 |
stack.push(i); |
7 |
|
8while (!stack.empty())
9 System.out.print(stack.pop() + " ");
10}
11}
9 8 7 6 5 4 3 2 1 0
How do you implement the StackOfIntegers class? The elements in the stack are stored in an array named elements. When you create a stack, the array is also created. The no-arg constructor creates an array with the default capacity of 16. The variable size counts the number of elements in the stack, and size – 1 is the index of the element at the top of the stack, as shown in Figure 10.12. For an empty stack, size is 0.
The StackOfIntegers class is implemented in Listing 10.8. The methods empty(), peek(), pop(), and getSize() are easy to implement. To implement push(int value), assign value to elements[size] if size < capacity (line 24). If the stack is full (i.e.,
elements[capacity 1] |
|
|
|
|
|
|
|
|
|
|
|
|
|
. |
|
|
|
|
|
|
|
|
|
|
|
. |
|
|
|
|
|
|
|
|
|
|
|
. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
elements[size 1] |
|
top |
|
|
|
|
capacity |
||||
|
|
. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||
|
|
. |
|
|
|
|
|
size |
|
|
|
|
|
. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
elements[1] |
|
|
|
|
|
|
|
|
|
|
|
elements[0] |
|
bottom |
|
|
|
|
|
|
FIGURE 10.12 The StackOfIntegers class encapsulates the stack storage and provides the operations for manipulating the stack.