0% found this document useful (0 votes)
30 views39 pages

Lecture 06 - A Closer Look at Methods and Classes - Part 1

Uploaded by

hasibul rojan
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
30 views39 pages

Lecture 06 - A Closer Look at Methods and Classes - Part 1

Uploaded by

hasibul rojan
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 39

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

You might also like