OpenStax-CNX module: m44182

Java1608: Polymorphism Based on

Overloaded Methods
R.G. (Dick) Baldwin
This work is produced by OpenStax-CNX and licensed under the

Creative Commons Attribution License 3.0

Abstract
Baldwin explains the use of overloaded methods for the purpose of achieving compile-time polymorphism.

1 Table of Contents

Preface (p. 1)
Viewing tip (p. 1)
* Listings (p. 1)

Preview (p. 2)
Discussion and sample code (p. 2)
Summary (p. 7)
What's next? (p. 7)
Miscellaneous (p. 7)
Complete program listings (p. 8)

Preface

This module is one of a series of modules designed to teach you about the essence of Object-Oriented
Programming (OOP) using Java.

2.1 Viewing tip

I recommend that you open another copy of this document in a separate browser window and use the
following links to easily nd and view the listings while you are reading about them.

2.1.1 Listings

Listing 1 (p.
Listing 2 (p.
Listing 3 (p.
Listing 4 (p.

Version

5) .
5) .
6) .
9) .

Denition of the class named A.

Denition of the class named B.
Denition of the driver class named Poly01.
Complete program listing.

1.3: Jan 1, 2013 10:59 pm -0600

http://creativecommons.org/licenses/by/3.0/

http://cnx.org/content/m44182/1.3/

OpenStax-CNX module: m44182

Preview

Previous modules introduced overloading and overriding methods. This module concentrates on the use
of method overloading to achieve compile-time polymorphism .
Every class in Java is a direct or indirect subclass of the class named Object . Methods dened in the
class named Object are inherited into all other classes. Inherited methods that are not declared nal
may be overridden to make their behavior more appropriate to objects instantiated from the new class.
Overloaded methods have the same name and dierent formal argument lists. They may or may not
have the same return type.
Polymorphism manifests itself in Java in the form of multiple methods having the same name. This module concentrates on method overloading, sometimes referred to as compile-time polymorphism . Subsequent
modules concentrate on method overriding, sometimes referred to as runtime polymorphism .
Overloaded methods may all be dened in the same class, or may be dened in dierent classes as long
as those classes have a superclass-subclass relationship.
4

Discussion and sample code

Three concepts

In an earlier module, I explained that most books on OOP will tell you that in order to understand OOP,
you must understand the following three concepts:
Encapsulation
Inheritance
Polymorphism

I agree with that assessment.

Encapsulation and inheritance

Previous modules in this series have explained Encapsulation and Inheritance. This module will tackle
the somewhat more complex topic of Polymorphism.

Overloading and overriding methods

In the modules on inheritance, you learned a little about overloading and overriding methods (you will
learn more about these concepts as you progress through these modules) . This module concentrates on the
use of overloaded methods to achieve compile-time polymorphism.

Real-world scenarios

The sample programs that I used in the previous modules in this series dealt with two kinds of car radios:
Plain car radios
Car radios having built-in tape players

I couched those programs in a real-world scenario in an attempt to convince you that encapsulation and
inheritance really do have a place in the real world.

Programs were fairly long

However, even though those programs were simple in concept, they were relatively long. That made them
somewhat dicult to explain due simply to the amount of code involved.

Keep it short and simple

Beginning with this module, I am going to back away from real-world scenarios and begin using sample
programs that are as short and as simple as I know how to make them, while still illustrating the important
points under discussion.
My objective in this and future modules is to make the polymorphic concepts as clear as possible without
having those concepts clouded by other programming issues.
I will simply ask you to trust me when I tell you that polymorphism has enormous applicability in the
real world.
http://cnx.org/content/m44182/1.3/

OpenStax-CNX module: m44182

A little more on inheritance

There is another aspect of inheritance that I didn't explain in the previous modules.

Every class extends some other class

Every class in Java extends some other class. If you don't explicitly specify the class that your new class
extends, it will automatically extend the class named Object .

A class hierarchy

Thus, all classes in Java exist in a class hierarchy where the class named Object forms the root of the
hierarchy.
Some classes extend Object directly, while other classes are subclasses of Object further down the
hierarchy.

Methods in the Object class

The class named Object denes default versions of the following methods:

clone()
equals(Object obj)
nalize()
getClass()
hashCode()
notify()
notifyAll()
toString()

wait()
wait(long timeout)
wait(long timeout, int nanos)

As you can see, this list includes three overloaded versions of the method named wait . The three versions
have the same name but dierent formal argument lists. Thus, these three methods are overloaded versions
of the method name wait .

Every class inherits these eleven methods

Because every class is either a direct or indirect subclass of Object , every class in Java, (including
new classes that you dene) , inherit these eleven methods.

To be overridden ...

Some of these eleven methods are intended to be overridden for various purposes. However, some of
them, such as getClass , notify , and the three versions of wait , are intended to be used directly
without overriding. (Although not shown here, these ve methods are declared to be nal , meaning that
they may not be overridden.)

What is polymorphism?

The meaning of the word polymorphism is something like one name, many forms.

How does Java implement polymorphism?

Polymorphism manifests itself in Java in the form of multiple methods having the same name.
In some cases, multiple methods have the same name, but dierent formal argument lists (overloaded
methods) . In other cases, multiple methods have the same name, same return type, and same formal
argument list (overridden methods) .

Three distinct forms of polymorphism

From a practical programming viewpoint, polymorphism manifests itself in three distinct forms in Java:
Method overloading
Method overriding through inheritance
Method overriding through the Java interface

Method overloading
http://cnx.org/content/m44182/1.3/

OpenStax-CNX module: m44182

I will begin the discussion of polymorphism with method overloading, which is the simplest of the three.
I will cover method overloading in this module and will cover polymorphism based on overridden methods
and interfaces in subsequent modules.

Method overloading versus method overriding

Don't confuse method overloading with method overriding .

Java allows you to have two or more method denitions in the same scope with the same name, provided
that they have dierent formal argument lists.
More specically, here is what Roberts, Heller, and Ernest have to say about overloading methods in
their excellent book titled The Complete Java 2 Certication Study Guide :
"A valid overload diers in the number or type of its arguments. Dierences in argument names are not
signicant. A dierent return type is permitted, but is not sucient by itself to distinguish an overloading
method."
Similarly, as a preview of things to come, here is what they have to say about method overriding:
"A valid override has identical argument types and order, identical return type, and is not less accessible
than the original method. The overriding method must not throw any checked exceptions that were not
declared for the original method."
You should read these two descriptions carefully and make certain that you recognize the dierences.

Compile-time polymorphism

Some authors refer to method overloading as a form of compile-time polymorphism , as distinguished

from run-time polymorphism .
This distinction comes from the fact that, for each method call, the compiler determines which method
(from a group of overloaded methods) will be executed, and this decision is made when the program is
compiled. (In contrast, I will tell you later that the determination of which overridden method to execute
isn't made until runtime.)

Selection based on the argument list

In practice, the compiler simply examines the types, number, and order of the parameters being passed
in a method call, and selects the overloaded method having a matching formal argument list.

A sample program

I will discuss a sample program named Poly01 to illustrate method overloading. A complete listing of
the program can be viewed in Listing 4 (p. 9) near the end of the module.

Within the class and the hierarchy

Method overloading can occur both within a class denition, and vertically within the class inheritance
hierarchy. (In other words, an overloaded method can be inherited into a class that denes other overloaded
versions of the method.) The program named Poly01 illustrates both aspects of method overloading.

Class B extends class A, which extends Object

Upon examination of the program, you will see that the class named A extends the class named
Object . You will also see that the class named B extends the class named A .
The class named Poly01 is a driver class whose main method exercises the methods dened in the
classes named A and B .
Once again, this program is not intended to correspond to any particular real-world scenario. Rather, it
is a very simple program designed specically to illustrate method overloading.

Will discuss in fragments

As is my usual approach, I will discuss this program in fragments. The code in Listing 1 (p. 5) denes
the class named A , which explicitly extends Object .

http://cnx.org/content/m44182/1.3/

OpenStax-CNX module: m44182

Listing 1: Denition of the class named A.

class A extends Object{
public void m(){
System.out.println("m()");
}//end method m()
}//end class A

Redundant code

Explicitly extending Object is not required (but it also doesn't hurt anything to do it) .
By default, the class named A would extend the class named Object automatically, unless the class
named A explicitly extends some other class.

The method named m()

The code in Listing 1 (p. 5) denes a method named m() . Note that this version of the method has an
empty argument list (it doesn't receive any parameters when it is executed) . The behavior of the method
is simply to display a message indicating that it has been called.

The class named B

Listing 2 (p. 5) contains the denition for the class named B . The class named B extends the class
named A , and inherits the method named m dened in the class named A .

Listing 2: Denition of the class named B.

class B extends A{
public void m(int x){
System.out.println("m(int x)");
}//end method m(int x)
//---------------------------------//
public void m(String y){
System.out.println("m(String y)");
}//end method m(String y)
}//end class B

Overloaded methods

In addition to the inherited method named m , the class named B denes two overloaded versions of
the method named m :
m(int x)
m(String y)
http://cnx.org/content/m44182/1.3/

OpenStax-CNX module: m44182

(Note that each of these two versions of the method receives a single parameter, and the type of the
parameter is dierent in each case.)
As with the version of the method having the same name dened in the class named A , the behavior
of each of these two methods is to display a message indicating that it has been called.

The driver class

Listing 3 (p. 6) contains the denition of the driver class named Poly01 .

Listing 3: Denition of the driver class named Poly01.

public class Poly01{
public static void main(String[] args){
B var = new B();
var.m();
var.m(3);
var.m("String");
}//end main
}//end class Poly01

Call all three overloaded methods

The code in the main method

Instantiates a new object of the class named B , and

Successively calls each of the three overloaded versions of the method named

that object.

m on the reference to

One version is inherited

The overloaded version of the method named m , dened in the class named A , is inherited into the
class named B . Therefore, it can be called on a reference to an object instantiated from the class named
B .

Two versions dened in class B

The other two versions of the method named m are dened in the class named B . Thus, they also
can be called on a reference to an object instantiated from the class named B .

The output

As you would expect, the output produced by sending messages to the object asking it to execute each
of the three overloaded versions of the method named m is:
m()
m(int x)
m(String y)

Note that the values of the parameters passed to the methods do not appear in the output. Rather, in this
simple example, the parameters are used solely to make it possible for the compiler to select the correct
version of the overloaded method to execute.
This output conrms that each overloaded version of the method is properly selected for execution based
on the matching of method parameters to the formal argument list of each method.

http://cnx.org/content/m44182/1.3/

OpenStax-CNX module: m44182

Summary

Previous modules introduced overloading and overriding methods. This module concentrates on the use
of method overloading to achieve compile-time polymorphism .
All classes in Java form a hierarchy with a class named Object at the root of the hierarchy. Thus,
every class in Java is a direct or indirect subclass of the class named Object .
If a new class doesn't explicitly extend some other class, it will, by default, automatically extend the
class named Object .
The Object class denes default versions of eleven dierent methods. These methods are inherited
into all other classes, and some (those not declared nal ) may be overridden to make their behavior
more appropriate for objects instantiated from the new class.
Overloaded methods have the same name and dierent formal argument lists. They may or may not
have the same return type.
Three of the eleven methods dened in the class named Object are overloaded versions of the method
name wait . One version takes no parameters. A second version takes a single parameter of type long .
The third version takes two parameters, one of type long , and one of type int .
The word polymorphism means something like one name, many forms . Polymorphism manifests itself
in Java in the form of multiple methods having the same name.
Polymorphism manifests itself in three distinct forms in Java:
Method overloading
Method overriding through inheritance
Method overriding through the Java interface

This module concentrates on method overloading , sometimes referred to as compile-time polymorphism .

This form of polymorphism is distinguished by the fact that the compiler selects a specic method from two
or more overloaded methods on the basis of the types and the number of parameters passed to the method
when it is called. The selection is made when the program is compiled (rather than being made later when
the program is run) .
Overloaded methods may all be dened in the same class, or may be dened in dierent classes as long
as those classes have a superclass-subclass relationship in the class hierarchy.
The sample program in this module illustrates three overloaded versions of the same method name with
two of the versions being dened in a single class, and the other version being dened in the superclass of
that class.
6

What's next?

The next module in this collection teaches you about assignment compatibility, type conversion, and casting
for both primitive and reference types.
It also teaches you about the relationship between reference types, method calls, and the location in the
class hierarchy where a method is dened.
7

Miscellaneous

This section contains a variety of miscellaneous information.

note:

Housekeeping material

Module name: Java OOP: Polymorphism Based on Overloaded Methods

File: Java1608.htm
Published: 02/11/02
Revised: 01/01/13

http://cnx.org/content/m44182/1.3/

OpenStax-CNX module: m44182

note:
Disclaimers: Financial : Although the Connexions site makes it possible for you to
download a PDF le for this module at no charge, and also makes it possible for you to purchase a
pre-printed version of the PDF le, you should be aware that some of the HTML elements in this
module may not translate well into PDF.
I also want you to know that, I receive no nancial compensation from the Connexions website even
if you purchase the PDF version of the module.
In the past, unknown individuals have misappropriated copies of my modules from cnx.org, converted them to Kindle books, and placed them for sale on Amazon.com showing me as the author.
I receive no compensation for those sales and don't know who does receive compensation. If you
purchase such a book, please be aware that it is a bootleg copy of a module that is freely available
on cnx.org.
Aliation : I am a professor of Computer Information Technology at Austin Community College
in Austin, TX.

Complete program listings

A complete listing of the program is shown in Listing 4 (p. 9) below.

http://cnx.org/content/m44182/1.3/

OpenStax-CNX module: m44182

Listing 4: Complete program listing.

/*File Poly01.java
Copyright 2002, R.G.Baldwin
Program output is:
m()
m(int x)
m(String y)
**************************************/
class A extends Object{
public void m(){
System.out.println("m()");
}//end method m()
}//end class A
//===================================//
class B extends A{
public void m(int x){
System.out.println("m(int x)");
}//end method m(int x)
//---------------------------------//
public void m(String y){
System.out.println("m(String y)");
}//end method m(String y)
}//end class B
//===================================//
public class Poly01{
public static void main(String[] args){
B var = new B();
var.m();
var.m(3);
var.m("String");
}//end main
}//end class Poly01

-end-

http://cnx.org/content/m44182/1.3/