- •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
476 Chapter 14 |
Abstract Classes and Interfaces |
||||||||
|
howToEat() method in an interface and let it serve as a common supertype for other classes. |
||||||||
|
For example, |
||||||||
|
public static void main(String[] args) { |
||||||||
|
|
|
Edible stuff = new Chicken(); |
|
|||||
|
|
|
eat(stuff); |
||||||
|
|
|
|
|
|||||
|
|
|
stuff = new Duck(); |
|
|
||||
|
|
|
eat(stuff); |
||||||
|
|
|
|
|
|
||||
|
|
|
stuff = new Broccoli(); |
|
|
||||
|
|
|
eat(stuff); |
||||||
|
} |
|
|
|
|
|
|
|
|
|
public static void eat(Edible stuff) { |
||||||||
|
|
|
stuff.howToEat(); |
|
|
|
|
||
|
} |
|
|
|
|
|
|
|
|
Edible interface |
interface Edible { |
||||||||
|
|
|
public String howToEat() |
; |
|
||||
|
} |
|
|
|
|
|
|
|
|
Chicken class |
class Chicken implements Edible { |
||||||||
|
|
|
public String howToEat() |
{ |
|
||||
|
|
|
return "Fry it"; |
||||||
|
} |
|
|
|
|
|
|
||
|
} |
|
|
|
|
|
|
|
|
Duck class |
class Duck implements Edible { |
||||||||
|
|
|
public String howToEat() |
{ |
|
||||
|
|
|
return "Roast it"; |
||||||
|
} |
|
|
|
|
|
|
||
|
} |
|
|
|
|
|
|
|
|
Broccoli class |
class Broccoli implements Edible { |
||||||||
|
|
|
public String howToEat() |
{ |
|
||||
|
|
|
return "Stir-fry it"; |
||||||
|
} |
|
|
|
|
|
|
||
|
} |
|
|
|
|
|
|
|
|
|
To define a class that represents edible objects, simply let the class implement the Edible |
||||||||
|
interface. The class is now a subtype of the Edible type. Any Edible object can be passed |
||||||||
|
to invoke the eat method. |
14.9 Processing Primitive Data Type Values as Objects
Owing to performance considerations, primitive data types are not used as objects in Java. Because of the overhead of processing objects, the language’s performance would be adversely affected if primitive data types were treated as objects. However, many Java methods require the use of objects as arguments. For example, the add(object) method in the ArrayList class adds an object to an ArrayList. Java offers a convenient way to incorporate, or wrap, a primitive data type into an object (e.g., wrapping int into the Integer class,
why wrapper class? and wrapping double into the Double class). The corresponding class is called a wrapper class. By using a wrapper object instead of a primitive data type variable, you can take advantage of generic programming.
Java provides Boolean, Character, Double, Float, Byte, Short, Integer, and Long wrapper classes for primitive data types. These classes are grouped in the java.lang package. Their inheritance hierarchy is shown in Figure 14.8.
14.9 Processing Primitive Data Type Values as Objects 477
Comparable |
Object |
why wrapper class? |
|
|
|
Number |
Character |
Boolean |
Double Float Long Integer Short Byte
FIGURE 14.8 The Number class is an abstract superclass for Double, Float, Long,
Integer, Short, and Byte.
Note
Most wrapper class names for a primitive type are the same as the primitive data type name with |
naming convention |
the first letter capitalized. The exceptions are Integer and Character. |
|
Each numeric wrapper class extends the abstract Number class, which contains the methods doubleValue(), floatValue(), intValue(), longValue(), shortValue(), and byteValue(). These methods “convert” objects into primitive type values. Each wrapper class overrides the toString and equals methods defined in the Object class. Since all the wrapper classes implement the Comparable interface, the compareTo method is implemented in these classes.
Wrapper classes are very similar to each other. The Character class was introduced in Chapter 9, “Strings and Text I/O.” The Boolean class wraps a Boolean value true or false. This section uses Integer and Double as examples to introduce the numeric wrapper classes. The key features of Integer and Double are shown in Figure 14.9.
java.lang.Number |
|
|
|
java.lang.Integer |
|
|
|
||
|
|
|
|
|
+byteValue(): byte |
|
|
|
-value: int |
+shortValue(): short |
|
|
|
+MAX_VALUE: int |
+intValue(): int |
|
|
|
+MIN_VALUE: int |
+longValue(): long |
|
|
|
|
|
|
|
|
|
+floatValue(): float |
|
|
|
+Integer(value: int) |
+doubleValue(): double |
|
|
|
+Integer(s: String) |
|
|
|
|
+valueOf(s: String): Integer |
|
|
|
|
|
|
|
|
|
+valueOf(s: String, radix: int): Integer |
«interface» |
|
|
|
|
|
|
|
+parseInt(s: String): int |
|
java.lang.Comparable |
|
|
|
+parseInt(s: String, radix: int): int |
|
|
|
|
|
+compareTo(o: Object): int |
|
|
|
|
|
|
|
|
java.lang.Double |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
-value: double |
|
|
|
|
+MAX_VALUE: double |
|
|
|
|
+MIN_VALUE: double |
|
|
|
|
|
|
|
|
|
+Double(value: double) |
|
|
|
|
+Double(s: String) |
|
|
|
|
+valueOf(s: String): Double |
|
|
|
|
+valueOf(s: String, radix: int): Double |
|
|
|
|
+parseDouble(s: String): double |
|
|
|
|
+parseDouble(s: String, radix: int): double |
|
|
|
|
|
FIGURE 14.9 The wrapper classes provide constructors, constants, and conversion methods for manipulating various data types.
478 Chapter 14 |
Abstract Classes and Interfaces |
constructors |
You can construct a wrapper object either from a primitive data type value or from a string |
|
representing the numeric value—for example, new Double(5.0), new Double("5.0"), |
|
new Integer(5), and new Integer("5"). |
no no-arg constructor |
The wrapper classes do not have no-arg constructors. The instances of all wrapper classes |
immutable |
are immutable; this means that, once the objects are created, their internal values cannot be |
|
changed. |
constants |
Each numeric wrapper class has the constants MAX_VALUE and MIN_VALUE. MAX_VALUE |
|
represents the maximum value of the corresponding primitive data type. For Byte, Short, |
|
Integer, and Long, MIN_VALUE represents the minimum byte, short, int, and long val- |
|
ues. For Float and Double, MIN_VALUE represents the minimum positive float and |
|
double values. The following statements display the maximum integer (2,147,483,647), the |
|
minimum positive float 11.4E -452, and the maximum double floating-point number |
|
11.79769313486231570e + 308d2. |
|
System.out.println("The maximum integer is " + Integer.MAX_VALUE); |
|
System.out.println("The minimum positive float is " + |
|
Float.MIN_VALUE); |
|
System.out.println( |
|
"The maximum double-precision floating-point number is " + |
|
Double.MAX_VALUE); |
conversion methods |
Each numeric wrapper class implements the abstract methods doubleValue(), |
|
floatValue(), intValue(), longValue(), and shortValue(), which are defined in |
|
the Number class. These methods return a double, float, int, long, or short value for |
|
the wrapper object. |
static valueOf methods |
The numeric wrapper classes have a useful static method, valueOf(String s). This |
|
method creates a new object initialized to the value represented by the specified string. For |
|
example, |
|
Double doubleObject = Double.valueOf("12.4"); |
|
Integer integerObject = Integer.valueOf("12"); |
static parsing methods |
You have used the parseInt method in the Integer class to parse a numeric string into an |
|
int value and the parseDouble method in the Double class to parse a numeric string into |
|
a double value. Each numeric wrapper class has two overloaded parsing methods to parse a |
|
numeric string into an appropriate numeric value based on 10 (decimal) or any specified |
|
radix (e.g., 2 for binary, 8 for octal, and 16 for hexadecimal). These methods are shown |
|
below: |
|
// These two methods are in the Byte class |
|
public static byte parseByte(String s) |
|
public static byte parseByte(String s, int radix) |
|
// These two methods are in the Short class |
|
public static short parseShort(String s) |
|
public static short parseShort(String s, int radix) |
|
// These two methods are in the Integer class |
|
public static int parseInt(String s) |
|
public static int parseInt(String s, int radix) |
|
// These two methods are in the Long class |
|
public static long parseLong(String s) |
|
public static long parseLong(String s, int radix) |
|
// These two methods are in the Float class |
|
public static float parseFloat(String s) |
|
public static float parseFloat(String s, int radix) |
14.10 Sorting an Array of Objects 479
// These two methods are in the Double class public static double parseDouble(String s)
public static double parseDouble(String s, int radix)
For example,
Integer.parseInt("11", 2) returns 3;
Integer.parseInt("12", 8) returns 10;
Integer.parseInt("13", 10) returns 13;
Integer.parseInt("1A", 16) returns 26;
Integer.parseInt("12", 2) would raise a runtime exception because 12 is not a binary number.
14.10 Sorting an Array of Objects
This example presents a static generic method for sorting an array of comparable objects. The objects are instances of the Comparable interface, and they are compared using the compareTo method. The method can be used to sort an array of any objects as long as their classes implement the Comparable interface.
To test the method, the program sorts an array of integers, an array of double numbers, an array of characters, and an array of strings. The program is shown in Listing 14.10.
LISTING 14.10 GenericSort.java
1 public class GenericSort {
2 public static void main(String[] args) {
3// Create an Integer array
4 Integer[] intArray = {new Integer(2), new Integer(4), 5 new Integer(3)};
6
7// Create a Double array
8 Double[] doubleArray = {new Double(3.4), new Double(1.3), 9 new Double(-22.1)};
10
11// Create a Character array
12Character[] charArray = {new Character('a'),
13new Character('J'), new Character('r')};
15// Create a String array
16String[] stringArray = {"Tom", "John", "Fred"};
18// Sort the arrays
19sort(intArray);
20sort(doubleArray);
21sort(charArray);
22sort(stringArray);
24// Display the sorted arrays
25System.out.print("Sorted Integer objects: ");
26printList(intArray);
27System.out.print("Sorted Double objects: ");
28printList(doubleArray);
29System.out.print("Sorted Character objects: ");
30printList(charArray);
31System.out.print("Sorted String objects: ");
32printList(stringArray);
33}
34
sort Integer objects sort Double objects sort Character objects sort String objects
480 Chapter 14 |
Abstract Classes and Interfaces |
|||
|
35 |
|
/** Sort an array of comparable objects */ |
|
generic sort method |
36 |
|
public static void sort(Comparable[] list) |
{ |
|
37 |
|
Comparable currentMin; |
|
|
38 |
|
int currentMinIndex; |
|
|
39 |
|
|
|
|
40 |
|
for (int i = 0; i < list.length - 1; i++) { |
|
|
41 |
|
// Find the maximum in the list[0..i] |
|
|
42 |
|
currentMin = list[i]; |
|
|
43 |
|
currentMinIndex = i; |
|
|
44 |
|
|
|
|
45 |
|
for (int j = i + 1; j < list.length; j++) { |
|
compareTo |
46 |
|
if (currentMin.compareTo(list[j]) > 0) { |
|
|
47 |
|
currentMin = list[j]; |
|
|
48 |
|
currentMinIndex = j; |
|
|
49 |
} |
|
|
|
50 |
} |
|
|
|
51 |
|
|
|
|
52 |
|
// Swap list[i] with list[currentMinIndex] if necessary; |
|
|
53 |
|
if (currentMinIndex != i) { |
|
|
54 |
|
list[currentMinIndex] = list[i]; |
|
|
55 |
|
list[i] = currentMin; |
|
|
56 |
} |
|
|
|
57 |
} |
|
|
|
58 |
} |
|
|
|
59 |
|
|
|
60/** Print an array of objects */
61public static void printList(Object[] list) {
62for (int i = 0; i < list.length; i++)
63System.out.print(list[i] + " ");
64System.out.println();
65}
66}
Sorted Integer objects: 2 3 4
Sorted Double objects: -22.1 1.3 3.4
Sorted Character objects: J a r
Sorted String objects: Fred John Tom
The algorithm for the sort method is the same as in §6.10.1, “Selection Sort.” The sort method in §6.10.1 sorts an array of double values. The sort method in this example can sort an array of any object type, provided that the objects are also instances of the Comparable interface. This is another example of generic programming. Generic programming enables a method to operate on arguments of generic types, making it reusable with multiple types.
Integer, Double, Character, and String implement Comparable, so the objects of these classes can be compared using the compareTo method. The sort method uses the compareTo method to determine the order of the objects in the array.
|
Tip |
Arrays.sort method |
Java provides a static sort method for sorting an array of any object type in the |
|
java.util.Arrays class, provided that the elements in the array are comparable. Thus you |
|
can use the following code to sort arrays in this example: |
java.util.Arrays.sort(intArray);
java.util.Arrays.sort(doubleArray);
java.util.Arrays.sort(charArray);
java.util.Arrays.sort(stringArray);