User-Defined Methods in Java Programming

Java Programming: From Problem
Analysis to Program Design, 5e
Chapter 7
User-Defined Methods
Chapter Objectives
• Understand how methods are used in Java
programming
• Learn about standard (predefined) methods
and discover how to use them in a program
• Learn about user-defined methods
• Examine value-returning methods,
including actual and formal parameters
Java Programming: From Problem Analysis to Program Design, 5e 2

Chapter Objectives (continued)
• Explore how to construct and use a value-
returning, user-defined method in a
program
• Learn how to construct and use user-
defined void methods in a program
• Explore variables as parameters
• Learn about the scope of an identifier
• Become aware of method overloading
Predefined Classes
• Methods already written and provided by
Java
• Organized as a collection of classes (class
libraries)
• To use: import package
• Method type: data type of value returned by
method

Predefined Classes (continued)




class Character
(Package: java.lang)

class Character
(Package: java.lang) (continued)

class Character
(Package: java.lang) (continued)

To simplify the use of (public) static methods of a class, Java 5.0
introduces the following import statements:
These are called static import statements. After including such

statements in your program, when you use a (public) static method
(or any other public static member) of a class, you can omit the
name of the class and the dot operator.

Syntax: Value-Returning Method

User-Defined Methods
• Value-returning methods
– Used in expressions
– Calculate and return a value
– Can save value for later calculation or print value
• modifiers: public, private, protected,
static, abstract, final
• returnType: type of the value that the method
calculates and returns (using return statement)
• methodName: Java identifier; name of method
Syntax
• Syntax: formal parameter list

-The syntax of the formal parameter list is:
• Method call
-The syntax to call a value-returning method is:

Syntax (continued)
• Syntax: actual parameter list
-The syntax of the actual parameter list is:
• Syntax: return statement

-The return statement has the following syntax:
return expr;

Equivalent Method Definitions
public static double larger(double x, double y)
{
double max;
if (x >= y)
max = x;
else
max = y;
return max;
}

(continued)
{
if (x >= y)
return x;
else
return y;
}

(continued)
{
if (x >= y)
return x;
return y;
}

The int variable num contains the desired sum to be rolled

Palindrome Number
• Palindrome: integer or string that reads the

same forward and backward
• The method isPalindrome takes a string
as a parameter and returns true if the
string is a palindrome, false otherwise

Solution: isPalindrome Method
public static boolean isPalindrome(String str)
{
int len = str.length();
int i, j;
j = len - 1;
for (i = 0; i <= (len - 1) / 2; i++)

{
if (str.charAt(i) != str.charAt(j))
return false;
j--;
}
return true;
}

Flow of Execution
• Execution always begins with the first statement
in the method main
• User-defined methods execute only when called
• Call to method transfers control from caller to
called method
• In method call statement, specify only actual
parameters, not data type or method type
• Control goes back to caller when method exits
Programming Example: Largest
Number
• Input: set of 10 numbers
• Output: largest of 10 numbers
• Solution
– Get numbers one at a time
– Method largest number: returns the larger of two
numbers
– For loop: calls method largest number on each number
received and compares to current largest number

Solution: Largest Number
static Scanner console = new Scanner(System.in);
public static void main(String[] args)

{
double num;
double max;
int count;
System.out.println("Enter 10 numbers.");
num = console.nextDouble();
max = num;
for (count = 1; count < 10; count++)
{
num = console.nextDouble();
max = larger(max, num);
}
System.out.println("The largest number is "
+ max);
}
Sample Run: Largest Number
• Sample Run
Enter 10 numbers:
10.5 56.34 73.3 42 22 67 88.55 26 62 11
The largest number is 88.55

Void Methods
• Similar in structure to value-returning
methods
• Call to method is always stand-alone
statement
• Can use return statement to exit method
early

Void Methods with Parameters: Syntax

Void Methods with Parameters:
Syntax (continued)

Primitive Data Type Variables as
Parameters
• A formal parameter receives a copy of its
corresponding actual parameter
• If a formal parameter is a variable of a
primitive data type:
– Value of actual parameter is directly stored
– Cannot pass information outside the method
– Provides only a one-way link between actual
parameters and formal parameters

Reference Variables as Parameters
• If a formal parameter is a reference variable:

– Copies value of corresponding actual parameter
– Value of actual parameter is address of the object
where actual data is stored
– Both formal and actual parameter refer to same
object

Uses of Reference Variables as
Parameters
• Can return more than one value from a
method
• Can change the value of the actual object
• When passing address, would save memory
space and time, relative to copying large
amount of data

Reference Variables as Parameters:
type String

type String (continued)



String str = "Hello"; //Line 5

stringParameter(str); //Line 7

pStr = "Sunny Day"; //Line 14

Variables before the statement in Line 8 executes

• The class StringBuffer contains the method append,
which allows you to append a string to an existing string, and
the method delete, which allows you to delete all the
characters of the string
• The assignment operator cannot be used with
StringBuffer variables; you must use the operator new
(initially) to allocate memory space for a string

Primitive Type Wrapper Classes as
Parameters
• If a formal parameter is of the primitive data type and the
corresponding actual parameter is a variable, then the formal
parameter cannot change the value of the actual parameter
• Only reference variables can pass values outside the method
(except, of course, for the return value)
• Corresponding to each primitive data type, Java provides a
class so that the values of primitive data types can be wrapped
in objects
• The class Integer does not provide a method to change the
value of an existing Integer object
• The same is true of other wrapper classes
Primitive Type Wrapper Classes as Parameters
(continued)
• If we want to pass a String object as a parameter and also
change that object, we can use the class StringBuffer
• Java does not provide any class that wraps primitive type
values in objects and when passed as parameters changes their
values
• If a method returns only one value of a primitive type, then
you can write a value-returning method
• If you encounter a situation that requires you to write a
method that needs to pass more than one value of a primitive
type, then you should design your own classes
• Appendix D provides the definitions of such classes and
shows how to use them in a program
Scope of an Identifier within a Class
• Local identifier: identifier declared within a method

or block, which is visible only within that method or
block
• Java does not allow the nesting of methods; you
cannot include the definition of one method in the
body of another method
• Within a method or a block, an identifier must be
declared before it can be used; a block is a set of
statements enclosed within braces

Scope of an Identifier within a
Class (continued)
• A method’s definition can contain several
blocks
– The body of a loop or an if statement also
form a block
• Within a class, outside of every method
definition (and every block), an identifier
can be declared anywhere

Class (continued)
• Within a method, an identifier used to name
a variable in the outer block of the method
cannot be used to name any other variable
in an inner block of the method
• For example, in the method definition on
the next slide, the second declaration of the
variable x is illegal

Class (continued)
public static void illegalIdentifierDeclaration()
{
int x;
//block
{
double x; //illegal declaration,
//x is already declared
...
}
}

Scope Rules
• Scope rules of an identifier declared within a
class and accessed within a method (block) of
the class
• An identifier, say x, declared within a method
(block) is accessible:
– Only within the block from the point at which it is
declared until the end of the block
– By those blocks that are nested within that block

Scope Rules (continued)
• Suppose x is an identifier declared within a class

and outside of every method’s definition (block)
– If x is declared without the reserved word static (such
as a named constant or a method name), then it cannot be
accessed in a static method
– If x is declared with the reserved word static (such as
a named constant or a method name), then it can be
accessed within a method (block), provided the method
(block) does not have any other identifier named x

Example 7-11
public class ScopeRules
{
static final double rate = 10.50;
static int z;
static double t;
public static void main(String[] args)
{
int num;
double x, z;
char ch;
//...
}
public static void one(int x, char y)
{
//...
}
public static int w;
public static void two(int one, int z)
{
char ch;
int a;
//block three
{
int x = 12;
//...
} //end block three
//...
}
}
Scope Rules: Demonstrated

Scope Rules: Demonstrated (continued)

Method Overloading:
An Introduction
• Method overloading: more than one method
can have the same name
• Two methods are said to have different
formal parameter lists if both methods have:
– A different number of formal parameters, or
– If the number of formal parameters is the same,
then the data type of the formal parameters, in the
order you list, must differ in at least one position

Method Overloading
public void methodOne(int x)
public void methodTwo(int x, double y)
public void methodThree(double y, int x)
public int methodFour(char ch, int x,
double y)
public int methodFive(char ch, int x,
String name)
• These methods all have different formal

parameter lists
Method Overloading (continued)
public void methodSix(int x, double y,
char ch)
public void methodSeven(int one, double u,
char firstCh)
• The methods methodSix and methodSeven

both have three formal parameters, and the data
type of the corresponding parameters is the same
• These methods all have the same formal parameter
lists
• Method overloading: creating several methods,
within a class, with the same name
• The signature of a method consists of the method
name and its formal parameter list
• Two methods have different signatures if they
have either different names or different formal
parameter lists
– Note that the signature of a method does not include
the return type of the method

• The following method headings correctly
overload the method methodXYZ:
public void methodXYZ()

public void methodXYZ(int x, double y)
public void methodXYZ(double one, int y)
public void methodXYZ(int x, double y,
char ch)

public void methodABC(int x, double y)
public int methodABC(int x, double y)
• Both these method headings have the same name

and same formal parameter list
• These method headings to overload the method
methodABC are incorrect
• In this case, the compiler will generate a syntax
error
– Notice that the return types of these method headings are different

Programming Example: Data
Comparison
• Input: data from two different files
• Data format: course number followed by scores
• Output: course number, group number, course
average
• Solution
– Read from more than one file, write output to file
– Generate bar graphs
– User-defined methods and re-use (calculateAverage and
printResult)
– Parameter passing

Comparison (continued)
Sample Output
Course No Group No Course Average
CSC 1 83.71
2 80.82
ENG 1 82.00
2 78.20
HIS 1 77.69
2 84.15
MTH 1 83.57
2 84.29
PHY 1 83.22
2 82.60
Avg for group 1: 82.04
Avg for group 2: 82.01

Comparison (continued)

• A program may contain a number of methods. In a complex
program, usually, when a method is written, it is tested and
debugged alone.
• You can write a separate program to test the method. The
program that tests a method is called a driver program.
• Before writing the complete program, you could write separate
driver programs to make sure that each method is working
properly.

• Sometimes the results calculated by one method are needed in
another method.
• In that case, the method that depends on another method cannot
be tested alone.
• A method stub is a method that is not fully coded.
• For a void method, a method stub might consist of only a
method header and a set of empty braces, {}.
• For a value-returning method it might contain only a return
statement with a plausible return value.

• If the problem is large and complex, it must be broken into
subproblems, and if a subproblem is still complex, it must further
be divided into subproblems.
• The subdivision of a problem should continue to the point where
the solution is clear and obvious.
• Once a subproblem is solved, we can continue with the solution of
another subproblem and if all the subproblems of a problem are
solved, we can continue with the next level.
• Eventually, the overall solution of the problem must be assembled
and tested to ensure that the programming code accomplishes the
required task.

• A Java program is a collection of classes, and a class is a
collection of data members and methods.
• Each class and each method must work properly.
• To accomplish this, as explained in the previous section, once a
method is written, it can be tested using stubs and drivers.
• Since a method can be tested in isolation, it is not necessary to
code all the methods in order.
• Once all the methods are written, the overall program must be
tested.

• The technique to solve a problem by subdividing into smaller
problems is known as divide and conquer and top-down design
approach.
• These techniques are suitable and work for many kinds of problems,
including most of the problems given in this book and the problems
you will encounter as a beginning programmer.
• To simplify the overall solution of a problem that consists of many
subproblems, we write and test the code one piece at a time.
• Typically, once a subproblem is solved and the code is tested, it is
saved as the first version or a version of the program.
• We continue to add and save the program one piece at a time. Keep
in mind that a working program with fewer features is better than a
nonworking one with many features.
Chapter Summary
• Predefined methods
• User-defined methods
– Value-returning methods
– Void methods
– Formal parameters
– Actual parameters
• Flow of execution

Chapter Summary (continued)
• Primitive data type variables as parameters
– One-way link between actual parameters and
formal parameters (limitations caused)
• Reference variables as parameters
– Can pass one or more variables from a method
– Can change value of actual parameter
• Scope of an identifier within a class
• Method overloading

Chapter Summary (continued)
• Debugging: using drivers and stubs
• Avoiding bugs: one-piece-at-a-time coding

User-Defined Methods in Java Programming

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

User-Defined Methods in Java Programming

Uploaded by

Copyright:

Available Formats

Java Programming: From Problem

Analysis to Program Design, 5e

Java Programming: From Problem Analysis to Program Design, 5e 2

Java Programming: From Problem Analysis to Program Design, 5e 4

Java Programming: From Problem Analysis to Program Design, 5e 5

Java Programming: From Problem Analysis to Program Design, 5e 6

Java Programming: From Problem Analysis to Program Design, 5e 7

Java Programming: From Problem Analysis to Program Design, 5e 8

Java Programming: From Problem Analysis to Program Design, 5e 9

Java Programming: From Problem Analysis to Program Design, 5e 10

Java Programming: From Problem Analysis to Program Design, 5e 11

These are called static import statements. After including such

Java Programming: From Problem Analysis to Program Design, 5e 12

Java Programming: From Problem Analysis to Program Design, 5e 17

• Syntax: formal parameter list

Java Programming: From Problem Analysis to Program Design, 5e 19

• Syntax: return statement

Java Programming: From Problem Analysis to Program Design, 5e 20

Java Programming: From Problem Analysis to Program Design, 5e 21

Java Programming: From Problem Analysis to Program Design, 5e 24

Java Programming: From Problem Analysis to Program Design, 5e 25

Java Programming: From Problem Analysis to Program Design, 5e 26

• Palindrome: integer or string that reads the

Java Programming: From Problem Analysis to Program Design, 5e 27

for (i = 0; i <= (len - 1) / 2; i++)

Java Programming: From Problem Analysis to Program Design, 5e 28

Java Programming: From Problem Analysis to Program Design, 5e 30

public static void main(String[] args)

Java Programming: From Problem Analysis to Program Design, 5e 32

Java Programming: From Problem Analysis to Program Design, 5e 33

Java Programming: From Problem Analysis to Program Design, 5e 34

Java Programming: From Problem Analysis to Program Design, 5e 35

Java Programming: From Problem Analysis to Program Design, 5e 36

• If a formal parameter is a reference variable:

Java Programming: From Problem Analysis to Program Design, 5e 37

Java Programming: From Problem Analysis to Program Design, 5e 38

Java Programming: From Problem Analysis to Program Design, 5e 39

Java Programming: From Problem Analysis to Program Design, 5e 40

Java Programming: From Problem Analysis to Program Design, 5e 41

Java Programming: From Problem Analysis to Program Design, 5e 42

Java Programming: From Problem Analysis to Program Design, 5e 43

Java Programming: From Problem Analysis to Program Design, 5e 44

Java Programming: From Problem Analysis to Program Design, 5e 45

Java Programming: From Problem Analysis to Program Design, 5e 46

Java Programming: From Problem Analysis to Program Design, 5e 47

• Local identifier: identifier declared within a method

Java Programming: From Problem Analysis to Program Design, 5e 55

Java Programming: From Problem Analysis to Program Design, 5e 56

Java Programming: From Problem Analysis to Program Design, 5e 57

Java Programming: From Problem Analysis to Program Design, 5e 58

Java Programming: From Problem Analysis to Program Design, 5e 59

• Suppose x is an identifier declared within a class

Java Programming: From Problem Analysis to Program Design, 5e 60

Java Programming: From Problem Analysis to Program Design, 5e 63

Java Programming: From Problem Analysis to Program Design, 5e 64

Java Programming: From Problem Analysis to Program Design, 5e 65

• These methods all have different formal

• The methods methodSix and methodSeven

Java Programming: From Problem Analysis to Program Design, 5e 68

public void methodXYZ()

Java Programming: From Problem Analysis to Program Design, 5e 69

• Both these method headings have the same name