BSCS 208: Advanced

Object Oriented
Programming

Lecture 4a - Polymorphism
Method overriding
Method overloading

1
Introduction to polymorphism
 Polymorphism is the ability to take more than
one form
 Earlier on we discussed polymorphism through
operator overloading where an operator like “+”
can be used for math addition, string
concatenation, and for matrix addition.
 This is equivalent to a word having different
meanings depending on the context

2
Introduction to polymorphism –
cont’d

 Polymorphism enables objects with

different internal structures to share the
same external interface
 This means same interface may be
accessed by different classes that work
differently as shown in figure below:

3
Fig: Polymorphism

<Shape>
Draw()

Circle Rectangle Triangle

Draw() Draw() Draw()

4
Introduction to polymorphism –
cont’d

 As we saw earlier, Java doesn’t

implement operator overloading except
the “+” operator
 This lecture discusses how to implement
polymorphism using method overriding
and method overloading.

5
Method overriding
 Overriding means redefining a method of
a class in its subclass
 The method name and signature
(number and type of parameters it
requires) remain unchanged i.e. only the
method body changes

6
Example: Overriding
public class Super {
int x;
Super(int x) {
this.x = x;
}
void display() {
System.out.println("Super x =
"+x);
}
}

7
public class Sub extends Super {
int y;
Sub (int x, int y) {
super(x);
this.y = y;
}
void display() {
System.out.println("Super x = "+ x);
System.out.println("Sub y = "+ y);
}
}

8
public class OverrrideTest {
public static void main(String args[]) {
Sub a = new Sub(100,200);
a.display();
}
}

9
 We use this keyword to access a variable of
the current class
 We use the inbuilt super method to access a
variable of the super class
 In the above example, the Sub class display()
method overrides the Super class display()
method
 If we call the Sub class, we get a different
behavior from that of the Super class

10
Example: overriding in Applets
 Applets always inherit from the Applet
class
 This class has methods such as init(),
start(), stop(), destroy().
 These methods are available for use by
applets to give them their runtime
behavior

11
 Applets are good examples of both the
inheritance and the polymorphism
principles.
 To make an applet unique, various life
cycle methods are overridden as shown
in example below

12
import java.awt.*;
import java.applet.*;

public class NestedApplet extends Applet {

// display params
int width=400;
int height=200;
int level=100;
int inc=10;
// first override the life cycle methods
public void init() {
System.out.println("Initializing");
incNesting();
}

13
public void start() {
System.out.println("Starting.");
incNesting();
}
public void stop() {
System.out.println("Stopping.");
incNesting();
}
public void destroy() {
System.out.println("Shutting down.");
incNesting();
}

14
public void paint(Graphics g) {
int i, shift=0; g.setColor(Color.blue);
for (i=0;i<level;i++) {
g.drawRect(shift,shift,width-2*shift-1,height-
2*shift-1);
shift = shift + inc;
}
g.drawString("Nesting level = "+level,width/2-
50,height/2+5);
}
public void incNesting() {
level++;
repaint();
}
}

15
Overloading
 Overloading is another technique to
implement polymorphism
 Here the method name is retained, but
the signature changes
 Used when a method is required to
perform similar tasks but using different
input parameters

16
Overloading – cont’d
 When we call a method, Java matches
the
• Method name,
• Number of parameters, and
• Type of parameters
 The matching method is then executed

17
Overloading – cont’d
 Overloading does not require inheritance
 All we need to do is define several
versions of the same method
• Defined methods should have different
number and type of parameters
• Change their body definition as appropriate
 We can overload both constructors and
ordinary methods

18
Overloading – cont’d
 In the example below, the constructor
method is overloaded such that one
takes one integer parameter and the
other takes two integer parameters
 The matching will be done at runtime,
depending on how many parameters you
supply

19
Example: Overloading
class Room {
int length, breadth;
Room(int x, int y) {
length = x;
breadth = y;
}
Room(int x) {
length = breadth=x;
}
int area() {
return(length*breadth);
}
}

20
class RectangleSquare {
public static void main(String args[]) {
Room room1 = new Room(25, 15);
Room room2 = new Room(20);
int area1 = room1.area();
int area2 = room2.area();
System.out.println("Area of Rectangle = "+area1);
System.out.println("Area of Square = "+area2);
}
}

21
Overloading vs. Overriding
 Don't confuse the concepts of overloading and overriding

 Overloading deals with multiple methods in the same class

with the same name but different signatures

 Overriding deals with two methods, one in a parent class

and one in a child class, that have the same signature

 Overloading lets you define a similar operation in different

ways for different data

 Overriding lets you define a similar operation in different

ways for different object types

22
Case study: Payroll system
 A company needs a payroll system for its
employees
 Refer to the Word document for a
complete source code of this system
 A UML captured in BlueJ is shown below

23
Case study: payroll system

24