- •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
156 Chapter 5 Methods
|
5.1 |
Introduction |
problem |
Suppose that you need to find the sum of integers from 1 to 10, from 20 to 30, and from 35 |
|
|
to 45, respectively. You may write the code as follows: |
|
|
int sum = 0; |
|
|
for (int i = 1; i <= 10; i++) |
|
|
|
sum += i; |
|
System.out.println("Sum from 1 to 10 is " + sum); |
|
|
sum = 0; |
|
|
for (int i = 20; i <= 30; i++) |
|
|
|
sum += i; |
|
System.out.println("Sum from 20 to 30 is " + sum); |
|
|
sum = 0; |
|
|
for (int i = 35; i <= 45; i++) |
|
|
|
sum += i; |
|
System.out.println("Sum from 35 to 45 is " + sum); |
|
|
You may have observed that computing sum from 1 to 10, from 20 to 30, and from 35 to 45 |
|
|
are very similar except that the starting and ending integers are different. Wouldn’t it be nice |
|
|
if we could write the common code once and reuse it without rewriting it? We can do so by |
|
why methods? |
defining a method. The method is for creating reusable code. |
|
|
The preceding code can be simplified as follows: |
|
define sum method |
1 |
public static int sum(int i1, int i2) { |
|
2 |
int sum = 0; |
|
3 |
for (int i = i1; i <= i2; i++) |
|
4 |
sum += i; |
|
5 |
|
|
6 |
return sum; |
|
7 |
} |
|
8 |
|
main method |
9 |
public static void main(String[] args) { |
invoke sum |
10 |
System.out.println("Sum from 1 to 10 is " + sum(1, 10)); |
|
11 |
System.out.println("Sum from 20 to 30 is " + sum(20, 30)); |
|
12 |
System.out.println("Sum from 35 to 45 is " + sum(35, 45)); |
|
13 |
} |
Lines 1–7 define the method named sum with two parameters i and j. The statements in the main method invoke sum(1, 10) to compute the sum from 1 to 10, sum(20, 30) to compute the sum from 20 to 30, and sum(35, 45) to compute the sum from 35 to 45.
A method is a collection of statements grouped together to perform an operation. In earlier chapters you have used predefined methods such as System.out.println, JOptionPane.showMessageDialog, JOptionPane.showInputDialog, Integer.parseInt, Double.parseDouble, System.exit, Math.pow, and Math.random. These methods are defined in the Java library. In this chapter, you will learn how to define your own methods and apply method abstraction to solve complex problems.
5.2 Defining a Method
The syntax for defining a method is as follows:
modifier returnValueType methodName(list of parameters) { // Method body;
}
5.2 Defining a Method 157
Let’s look at a method created to find which of two integers is bigger. This method, named max, has two int parameters, num1 and num2, the larger of which is returned by the method. Figure 5.1 illustrates the components of this method.
Define a method
|
|
|
|
|
modifier |
return value |
method |
formal |
||||||
|
|
|
|
|
type |
name |
parameters |
|||||||
method |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||
|
|
|
|
|
|
|
|
|
|
|
|
|
||
|
public static int |
max(int num1, int num2) |
{ |
|||||||||||
header |
|
|||||||||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
||
method |
|
|
|
int result; |
|
|
|
|
|
|||||
|
|
|
|
|
|
|
|
|||||||
|
|
|
|
|
|
|
|
|
|
|
|
|
||
body |
|
|
|
if (num1 > num2) |
parameter list method |
|||||||||
|
|
|
||||||||||||
|
|
|
|
|
|
|
signature |
|||||||
|
|
|
|
|
|
result = num1; |
|
|
||||||
|
|
|
|
|
|
|
|
|
|
|
||||
|
|
|
|
|
else |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
result = num2; |
|
|
|
|
|
|||
return result;
return value
}
FIGURE 5.1 A method definition consists of a method header and a method body.
Invoke a method
int z = max(x, y);
actual parameters (arguments)
The method header specifies the modifiers, return value type, method name, and |
method header |
parameters of the method. The static modifier is used for all the methods in this chapter. The |
|
reason for using it will be discussed in Chapter 8, “Objects and Classes.” |
|
A method may return a value. The returnValueType is the data type of the value the |
|
method returns. Some methods perform desired operations without returning a value. In this |
|
case, the returnValueType is the keyword void. For example, the returnValueType is |
|
void in the main method, as well as in System.exit, System.out.println, and |
|
JOptionPane.showMessageDialog. If a method returns a value, it is called a value- |
value-returning method |
returning method, otherwise it is a void method. |
void method |
The variables defined in the method header are known as formal parameters or simply |
|
parameters. A parameter is like a placeholder. When a method is invoked, you pass a value to the |
parameter |
parameter. This value is referred to as an actual parameter or argument. The parameter list |
argument |
refers to the type, order, and number of the parameters of a method. The method name and the |
parameter list |
parameter list together constitute the method signature. Parameters are optional; that is, a method |
method signature |
may contain no parameters. For example, the Math.random() method has no parameters. |
|
The method body contains a collection of statements that define what the method does. |
|
The method body of the max method uses an if statement to determine which number is |
|
larger and return the value of that number. In order for a value-returning method to return a |
|
result, a return statement using the keyword return is required. The method terminates when |
|
a return statement is executed. |
|
Note
In certain other languages, methods are referred to as procedures and functions. A value-returning method is called a function; a void method is called a procedure.
Caution
In the method header, you need to declare a separate data type for each parameter. For instance, max(int num1, int num2) is correct, but max(int num1, num2) is wrong.
Note
We say “define a method” and “declare a variable.” We are making a subtle distinction here. A |
define vs. declare |
definition defines what the defined item is, but a declaration usually involves allocating memory |
|
to store data for the declared item. |
|
158 Chapter 5 Methods
Video Note
Define/invoke max method
main method
invoke max
define method
5.3 Calling a Method
In creating a method, you define what the method is to do. To use a method, you have to call or invoke it. There are two ways to call a method, depending on whether the method returns a value or not.
If the method returns a value, a call to the method is usually treated as a value. For example,
int larger = max(3, 4);
calls max(3, 4) and assigns the result of the method to the variable larger. Another example of a call that is treated as a value is
System.out.println(max(3, 4));
which prints the return value of the method call max(3, 4).
If the method returns void, a call to the method must be a statement. For example, the method println returns void. The following call is a statement:
System.out.println("Welcome to Java!");
Note
A value-returning method can also be invoked as a statement in Java. In this case, the caller simply ignores the return value. This is not often done but is permissible if the caller is not interested in the return value.
When a program calls a method, program control is transferred to the called method. A called method returns control to the caller when its return statement is executed or when its methodending closing brace is reached.
Listing 5.1 shows a complete program that is used to test the max method.
LISTING 5.1 TestMax.java
1 public class TestMax {
2/** Main method */
3 public static void main(String[] args) {
4 int i = 5;
5int j = 2;
6int k = max(i, j);
7 System.out.println("The maximum between " + i + 8 " and " + j + " is " + k);
9 }
10
11/** Return the max between two numbers */
12public static int max(int num1, int num2) {
13int result;
14
15if (num1 > num2)
16result = num1;
17else
18result = num2;
20return result;
21}
22}
The maximum between 5 and 2 is 5
5.3 Calling a Method 159
|
|
line# |
i |
j |
k |
num1 |
num2 |
result |
|
|
|
|
|
|
|
|
|
|
|
|
|
4 |
5 |
|
|
|
|
|
|
|
|
5 |
|
2 |
|
|
|
|
|
|
|
12 |
|
|
|
5 |
2 |
|
|
Invoking max |
13 |
|
|
|
|
|
undefined |
||
|
|
16 |
|
|
|
|
|
5 |
|
|
|
6 |
|
|
5 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
This program contains the main method and the max method. The main method is just like |
main method |
any other method except that it is invoked by the JVM. |
|
The main method’s header is always the same. Like the one in this example, it includes the |
|
modifiers public and static, return value type void, method name main, and a parameter |
|
of the String[] type. String[] indicates that the parameter is an array of String, a sub- |
|
ject addressed in Chapter 6. |
|
The statements in main may invoke other methods that are defined in the class that con- |
|
tains the main method or in other classes. In this example, the main method invokes max(i, |
|
j), which is defined in the same class with the main method. |
|
When the max method is invoked (line 6), variable i’s value 5 is passed to num1, and vari- |
max method |
able j’s value 2 is passed to num2 in the max method. The flow of control transfers to the max |
|
method. The max method is executed. When the return statement in the max method is exe- |
|
cuted, the max method returns the control to its caller (in this case the caller is the main |
|
method). This process is illustrated in Figure 5.2. |
|
pass the value i
pass the value j
public static void main(String[] args) { int i = 5;
int j = 2;
int k = max(i, j);
System.out.println(
"The maximum between " + i + " and " + j + " is " + k);
}
public static int max(int num1, int num2) { int result;
if (num1 > num2) result = num1;
else
result = num2;
return result;
}
FIGURE 5.2 When the max method is invoked, the flow of control transfers to it. Once the max method is finished, it returns control back to the caller.
Caution
A return statement is required for a value-returning method. The method shown below in (a) is logically correct, but it has a compile error because the Java compiler thinks it possible that this method returns no value.
To fix this problem, delete if (n < 0) in (a), so that the compiler will see a return statement to be reached regardless of how the if statement is evaluated.