A Closer Look at

Methods and Classes

Part 1
Java - The Complete Reference
Herbert Schildt
Chapter 7
 Outline

• Overloading Methods
• Overloading Constructors
• Using Objects as Parameters
• A Closer Look at Argument Passing
• Returning Objects
• Recursion
• Introducing Access Control
Overloading Methods
 Overloading Methods
• In Java, it is possible to define two or more methods within the same class that share
the same name, as long as their parameter declarations are different.
• When this is the case, the methods are said to be overloaded, and the process is
referred to as method overloading.
• Method overloading is one of the ways that Java supports polymorphism.
• When an overloaded method is invoked, Java uses the type and/or number of
arguments as its guide to determine which version of the overloaded method to
actually call.
• Overloaded methods must differ in the (1) data type and/or (2) number of their
parameters.
• While overloaded methods may have different return types, the return type alone is
insufficient to distinguish two versions of a method.
Overloading Methods: Example
OUTPUT
 Type Conversion in Overloading Methods
• When an overloaded method is called, Java looks for a match between the arguments
used to call the method and the method’s parameters.
• However, this match need not always be exact.
• In some cases, Java’s automatic type conversions can play a role in overload
resolution.
Example
OUTPUT

• For the last call to add()

method, no exact match is
found.

• So, Java automatically converts

int value 2 to double and
calls add(double,
double) version.

• Java will employ its automatic

type conversions only if no
exact match is found.
 Usefulness of Method Overloading
• Method overloading supports polymorphism because it is one way that Java
implements the one interface, multiple methods paradigm.
• Example: In C, the function abs() returns the absolute value of an integer,
labs() returns the absolute value of a long integer, and fabs() returns the
absolute value of a floating-point value.
• Since C does not support overloading, each function has its own name, even
though all three functions do essentially the same thing.
• In Java, the standard class library includes an absolute value method, called abs().
• This method is overloaded by Java’s Math class to handle all numeric types.
• Java determines which version of abs()to call based upon the type of argument.
• Math Class Java Doc
https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html
• In practice, we should only overload closely related operations.
Overloading Constructors
 Overloading Constructors
• The concept of overloading is very useful and common for constructors.
• Example: If a Box class is defined as below, all declarations of Box objects must
pass three arguments to the Box( ) constructor.
• So, the following statement will
generate compilation error:

Box ob = new Box();

• What if we simply want a box and do
not care (or know) what its initial
dimensions were?
• What if we want to be able to initialize
a cube by specifying only one value that
would be used for all three dimensions?
Overloading Constructors: Example

OUTPUT
Using Objects as Parameters
 Using Objects as Parameters
• Similar to basic data types, objects can be passed to methods as parameters.
OUTPUT

• The equalTo() method

compares the invoking
object with the one that it is
passed.
 Passing Objects to Constructors

• One of the most common uses of object parameters involves

constructors.
• Many a times we want to construct a new object so that it is initially the
same as some existing object.
• To do this, we must define a constructor that takes an object of its class
as a parameter.
Passing Objects to Constructors: Example

OUTPUT
A Closer Look at Argument Passing
 A Closer Look at Argument Passing
• There are two ways of argument passing:
1. Call-by-value
2. Call-by-reference

Call-by-value
• Copies the value of an argument into the formal parameter of the method.
• So, changes made to the parameter of the method have no effect on the argument.
Call-by-reference
• A reference to an argument (not the value of the argument) is passed to the parameter.
• Inside the method, this reference is used to access the actual argument specified in the
call.
• So, changes made to the parameter will affect the argument used to call the method.
 Call-by-value: Example

OUTPUT
 Call-by-reference: Example
• When we pass
an object
reference to a
method, the
parameter that
receives it will
refer to the same
object as that
referred to by
the argument.
• Changes to the
object inside the
method do affect
the object used
OUTPUT as an argument.
Returning Objects
 Returning Objects
• A method can return any type of data, including class types that we create.
• Example, in the following program, the incrByTen() method returns an object in
which the value of a is ten greater than it is in the invoking object.

OUTPUT
 Returning Objects
• Each time incrByTen() is invoked, a new object is created, and a reference to it
is returned to the calling routine.
• Another point: Since all objects are dynamically allocated using new, we don’t need
to worry about an object going out of scope because the method in which it was
created terminates.
• The object will continue to exist as long as there is a reference to it somewhere in
your program.
• When there are no references to it, the object will be reclaimed the next time
garbage collection takes place.
Recursion
 Recursion

• Java supports recursion.

• Recursion is the process of defining something in terms of itself.
• In programming, recursion is the attribute that allows a method or function to call
itself.
• A method that calls itself is said to be recursive.
Example
• Computation of the factorial of a number.
• The factorial of a number N is the product of all the whole numbers between 1 and N.
• 3 factorial (3!) is 1 × 2 × 3, or 6.
Recursion: Factorial Computation
OUTPUT
Recursion: Factorial Computation
• When fact( ) is called
with an argument of 1,
the function returns 1;
otherwise, it returns the
product of fact(n–1)*n.
• To evaluate this
expression, fact( ) is
called with n–1.
• This process repeats until
n equals 1 and the calls to
the method begin
returning.
 Recursion: Analysis
• When a method calls itself, new local variables and parameters are allocated storage
on the stack, and the method code is executed with these new variables from the start.
• As each recursive call returns, the old local variables and parameters are removed
from the stack, and execution resumes at the point of the call inside the method.
Disadvantage of Recursion
• Recursive versions of many routines may execute a bit more slowly than the iterative
equivalent because of the added overhead of the additional method calls.
• Many recursive calls to a method could cause a stack overrun.
• Because storage for parameters and local variables is on the stack and each new call
creates a new copy of these variables, it is possible that the stack could be exhausted.
• If this occurs, the Java run-time system will cause an exception.
 Recursion: Analysis
Advantage of Recursion
• The main advantage to recursive methods is that they can be used to create clearer
and simpler versions of several algorithms than can their iterative relatives.
• For example, the QuickSort sorting algorithm is quite difficult to implement in
an iterative way.
• Also, some types of AI-related algorithms are most easily implemented using
recursive solutions.
 Common Errors in Recursion
• When writing recursive methods, we must have an if statement somewhere to
force the method to return without the recursive call being executed.
• If we don’t do this, once we call the method, it will never return.
• This is a very common error in working with recursion.
• Use println() statements liberally during development so that we can watch
what is going on and abort execution if we see that we have made a mistake.
Recursive Array Printing
OUTPUT
Introducing Access Control
 Introducing Access Control

• In OOP, encapsulation links data with the code that manipulates it.
• Encapsulation also provides another important attribute: Access
Control.
• Through encapsulation, we can control what parts of a program can
access the members of a class.
• By controlling access, we can prevent misuse.
• For example, allowing access to data only through a well-defined set of
methods, we can prevent the misuse of that data.
• Thus, when correctly implemented, a class creates a “black box” which
may be used, but the inner workings of which are not open to tampering.
Introducing Access Control: Stack Example
 Introducing Access Control: Stack Example

• In the Stack class, while it is true that the methods push() and
pop() do provide a controlled interface to the stack, this interface is not
enforced.
• That is, it is possible for another part of the program to bypass these
methods and access the stack directly.
• Of course, in the wrong hands, this could lead to trouble.
 Access Modifiers

• How a member can be accessed is determined by the access modifier

attached to its declaration.
• Java supplies a rich set of access modifiers.
• Some aspects of access control are related mostly to inheritance or
packages.
• In this part, we examine access control that applies to a single class.
• Java’s access modifiers are public, private, protected, and
default.
• protected applies to inheritance and will be discussed later.
 Access Modifier: public & private

• When a member of a class is modified by public, then that member

can be accessed by any other code.
• When a member of a class is specified as private, then that member
can only be accessed by other members of its class.
• The main() method has always been preceded by the public modifier
because it is called by code that is outside the program—that is, by the
Java run-time system.
• When no access modifier is used, then by default the member of a class
is public within its own package, but cannot be accessed outside of its
package.
 Access Modifier: public & private

• For the sake of achieving encapsulation, usually we will want to restrict

access to the data members of a class—allowing access only through
methods.
• Also, there will be times when we will want to define methods that are
private to a class.
• An access modifier must begin a member’s declaration statement.
public & private: Example
• Methods used to
access private
members are
often called
“getters and
setters”, or
“accessors and
mutators”.
Stack Class with Access Modifiers