- •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
390 Chapter 11 |
Inheritance and Polymorphism |
|
else |
|
return false; |
|
} |
|
Note |
== vs. equals |
The == comparison operator is used for comparing two primitive data type values or for deter- |
|
mining whether two objects have the same references. The equals method is intended to test |
|
whether two objects have the same contents, provided that the method is overridden in the |
|
defining class of the objects. The == operator is stronger than the equals method, in that the |
|
== operator checks whether the two reference variables refer to the same object. |
|
Caution |
|
Using the signature equals(SomeClassName obj) (e.g., equals(Circle c)) to over- |
equals(Object) |
ride the equals method in a subclass is a common mistake. You should use equals(Object |
|
obj). See Review Question 11.15. |
11.11 The ArrayList Class
Video Note
the ArrayList class
Now we are ready to introduce a very useful class for storing objects. You can create an array to store objects. But, once the array is created, its size is fixed. Java provides the ArrayList class that can be used to store an unlimited number of objects. Figure 11.3 shows some methods in ArrayList.
java.util.ArrayList
+ArrayList()
+add(o: Object): void
+add(index: int, o: Object): void +clear(): void
+contains(o: Object): boolean +get(index: int): Object +indexOf(o: Object): int +isEmpty(): boolean +lastIndexOf(o: Object): int +remove(o: Object): boolean +size(): int
+remove(index: int): boolean +set(index: int, o: Object): Object
FIGURE 11.3 An ArrayList stores an unlimited number of objects.
Listing 11.8 gives an example of using ArrayList to store objects.
LISTING 11.8 TestArrayList.java
1 public class TestArrayList {
2 public static void main(String[] args) {
|
3 |
// |
Create a |
list to |
store cities |
|
create ArrayList |
4 |
java.util.ArrayList |
cityList = new java.util.ArrayList(); |
|||
|
5 |
|
|
|
|
|
|
6 |
// |
Add some |
cities in the list |
||
add element |
7 |
cityList.add("London"); |
|
|||
11.11 The ArrayList Class 391
8// cityList now contains [London]
9cityList.add("Denver");
10// cityList now contains [London, Denver]
11cityList.add("Paris");
12// cityList now contains [London, Denver, Paris]
13cityList.add("Miami");
14// cityList now contains [London, Denver, Paris, Miami]
15cityList.add("Seoul");
16// contains [London, Denver, Paris, Miami, Seoul]
17cityList.add("Tokyo");
18// contains [London, Denver, Paris, Miami, Seoul, Tokyo]
20System.out.println("List size? " + cityList.size() );
21System.out.println("Is Miami in the list? " +
22cityList.contains("Miami") );
23System.out.println("The location of Denver in the list? "
24+ cityList.indexOf("Denver"));
25System.out.println("Is the list empty? " +
26cityList.isEmpty() ); // Print false
27
28// Insert a new city at index 2
29cityList.add(2, "Xian");
30// contains [London, Denver, Xian, Paris, Miami, Seoul, Tokyo]
32// Remove a city from the list
33cityList.remove("Miami");
34// contains [London, Denver, Xian, Paris, Seoul, Tokyo]
36// Remove a city at index 1
37cityList.remove(1);
38// contains [London, Xian, Paris, Seoul, Tokyo]
40// Display the contents in the list
41 |
System.out.println(cityList.toString()); |
42 |
|
43// Display the contents in the list in reverse order
44for (int i = cityList.size() - 1; i >= 0; i--)
45System.out.print(cityList.get(i) + " ");
46System.out.println();
47
48// Create a list to store two circles
49java.util.ArrayList list = new java.util.ArrayList();
51// Add two circles
52list.add(new Circle4(2));
53list.add(new Circle4(3));
55// Display the area of the first circle in the list
56System.out.println("The area of the circle? " +
57((Circle4)list.get(0)).getArea());
58}
59}
List size? 6
Is Miami in the list? true
The location of Denver in the list? 1 Is the list empty? false
[London, Xian, Paris, Seoul, Tokyo] Tokyo Seoul Paris Xian London
The area of the circle? 12.566370614359172
list size
contains element?
element index
is empty?
remove element
remove element
toString()
get element
create ArrayList
392 Chapter 11 |
Inheritance and Polymorphism |
|
The program creates an ArrayList using its no-arg constructor (line 4). The add method |
|
adds any instance of Object into the list. Since String is a subclass of Object, strings can |
|
be added to the list. The add method (lines 7–17) adds an object to the end of list. So, after |
|
cityList.add("London") (line 7), the list contains |
|
[London] |
add(Object) |
After cityList. add("Denver") (line 9), the list contains |
|
[London, Denver] |
|
After adding Paris, Miami, Seoul, and Tokyo (lines 11–17), the list would contain |
|
[London, Denver, Paris, Miami, Seoul, Tokyo] |
size() |
Invoking size() (line 20) returns the size of the list, which is currently 6. Invoking |
|
contains("Miami") (line 22) checks whether the object is in the list. In this case, it returns |
|
true, since Miami is in the list. Invoking indexOf("Denver") (line 24) returns the index |
|
of the object in the list, which is 1. If the object is not in the list, it returns -1. The isEmpty() |
|
method (line 26) checks whether the list is empty. It returns false, since the list is not empty. |
|
The statement cityList.add(2, "Xian") (line 29) inserts an object to the list at the |
add(index, Object) |
specified index. After this statement, the list becomes |
|
[London, Denver, Xian, Paris, Miami, Seoul, Tokyo] |
remove(Object) |
The statement cityList. remove("Miami") (line 33) removes the object from the list. |
|
After this statement, the list becomes |
|
[London, Denver, Xian, Paris, Seoul, Tokyo] |
remove(index) |
The statement cityList. remove(1) (line 37) removes the object at the specified index |
|
from the list. After this statement, the list becomes |
|
[London, Xian, Paris, Seoul, Tokyo] |
toString()
getIndex()
compiler warning
array vs. ArrayList
The statement in line 41 is same as
System.out.println(cityList);
The toString() method returns a string representation for the list in the form of
[e0.toString(), e1.toString(), ..., ek.toString()], where e0, e1, Á , and ek are the elements in the list.
The get(index) method (line 45) returns the object at the specified index.
Note
You will get the following warning when compiling this program from the command prompt:
Note: TestArrayList.java uses unchecked or unsafe operations. Note: Recompile with –Xlint:unchecked for details.
This warning can be eliminated using generic types discussed in Chapter 21, “Generics”. For now, ignore it. Despite the warning, the program will be compiled just fine to produce a .class file.
ArrayList objects can be used like arrays, but there are many differences. Table 11.1 lists their similarities and differences.
Once an array is created, its size is fixed. You can access an array element using the square-bracket notation (e.g., a[index]). When an ArrayList is created, its size is 0. You cannot use the get and set methods if the element is not in the list. It is easy to add, insert,
|
|
11.12 A Custom Stack Class 393 |
|
TABLE 11.1 Differences and Similarities between Arrays and ArrayList |
|||
|
|
|
|
Operation |
Array |
ArrayList |
|
|
|
|
|
Creating an array/ArrayList |
Object[] a = new Object[10] |
ArrayList list = new ArrayList(); |
|
Accessing an element |
a[index] |
list.get(index); |
|
Updating an element |
a[index] = "London"; |
list.set(index, "London"); |
|
Returning size |
a.length |
list.size(); |
|
Adding a new element |
|
list.add("London"); |
|
Inserting a new element |
|
list.add(index, "London"); |
|
Removing an element |
|
list.remove(index); |
|
Removing an element |
|
list.remove(Object); |
|
Removing all elements |
|
list.clear(); |
|
and remove elements in a list, but it is rather complex to add, insert, and remove elements in an array. You have to write code to manipulate the array in order to perform these operations.
Note
java.util.Vector is also a class for storing objects, which is very similar to the ArrayList class. All the methods in ArrayList are also available in Vector. The Vector class was introduced in JDK 1.1. The ArrayList class introduced in JDK 1.2 was intended to replace the
Vector class. Vector class
11.12 A Custom Stack Class
“Designing a Class for Stacks” in §10.8 presented a stack class for storing int values. This section introduces a stack class to store objects. You can use an ArrayList to implement Stack, as shown in Listing 11.9. The UML diagram for the class is shown in Figure 11.4.
Video Note
the MyStack class
MyStack |
|
|
|
|
|
-list: ArrayList |
|
A list to store elements. |
|
|
|
+isEmpty(): boolean |
|
Returns true if this stack is empty. |
+getSize(): int |
|
Returns the number of elements in this stack. |
+peek(): Object |
|
Returns the top element in this stack. |
+pop(): Object |
|
Returns and removes the top element in this stack. |
+push(o: Object): void |
|
Adds a new element to the top of this stack. |
+search(o: Object): int |
|
Returns the position of the first element in the stack from |
|
|
the top that matches the specified element. |
|
|
|
FIGURE 11.4 The MyStack class encapsulates the stack storage and provides the operations for manipulating the stack.
LISTING 11.9 MyStack.java
1 |
public class MyStack |
{ |
|
||
2 |
|
private java.util.ArrayList list = new java.util.ArrayList(); |
array list |
||
3 |
|
|
|
|
|
4 |
|
public boolean isEmpty() |
{ |
stack empty? |
|
5 |
|
return list.isEmpty(); |
|
||
6}