Chapter Five

Polymorhism
By: Biruk M.

1
 outline
Methods
 Call by value/reference?

Interface
 Multiple methods in interface
 Multiple interface

Polymorphism
 overloading
 Overriding
 Referenceing of classes

Abstract class
 abstract methods

2
 Method
A Java method is a collection of statements that are
grouped together to perform an operation.
 Eg:- When you call the System.out.println() method,
 the system actually executes several statements in order to display a
message on the console.

Syntax
public static int methodName(int a, int b) {
// body
}

Or
modifier returnType nameOfMethod (Parameter List) {
// method body
}
3
 examples  Passing Parameters by Value means
calling a method with a parameter.
Through this, the argument value is
 public static int minFunction(int n1, passed to the parameter.
int n2) {  The values of the arguments remains the
same even after the method invocation.
int min;
 Example
if (n1 > n2)
min = n2;  Public static void main(String
args[])
else { int x=10,y=20;
min = n1; Value of x and y?
S.O.P(add(x,y))
Value of x and y?
return min; }
}  Public static int add(int x,int y)
 {x=x+3;
 Y=y+5;
 Return (x+y);

}
 Can we use passing by Reference in java?
How? 4
 2. Interface
 set of methods with signature and parameters but not
implemented only the class will implement in its own interest
 An interface is a blueprint of class/ a contract for a class.

 It has constants and abstract methods

 interface gives 100% abstraction, so it is called fully abstraction.
 An interface declaration consists of modifiers, the
keyword interface, the interface name, a comma-separated list of
parent interfaces (if any), and the interface body.
 To declare a class that implements an interface, you include
an implements clause in the class declaration.
 There is no executable body for any method that is left to each class
that implements the interface
 Interface also represent IS-A relationship.

Why use interface?

 It is use to achieve fully abstraction.
 By using interface we achieve multiple inheritances. 5
  Eg:-
Cont…  public interface Hello {
Syntax: public String dispMsg() ;

 The interface keyword is }

used to declare an  Implementer class:
interface.  public class MsgImp
 public interface Interface- implements Hello {
name{ public String dispMsg()
//Any number of final, static fie {
lds return "Hello World!";
//Any number of abstract meth }
od declarations
public static void main(String
} args[]) {
MsgImp xx=new MsgImp();
System.out.println(xx.dispMsg())
;
}
}
6
 Multiple methods in interface
 public interface Sample {
public int sum(int x, int y) ;
Eg:- public int prod(int x, int y) ;
 Interfaces may specify but do not }
implement methods.
 public class SamImpl
 A class that implements the implements sample {
interface must implement all its public int sum(int x, int y)
methods.
{ return x+y; }
 If you want not to implement public int prod(int x, int y)
the methods u can use empty {return x*y; }
body for void functions or public static void main(String
return 0 for type-functions args[]){
 public int sum(int x, int y) SamImpl xx=new SamImpl();
{ System.out.println(xx.sum(4,9));
return 0; System.out.println(xx.prod(4,9));
} }
 }
7
  public class MultipleInterface implements
Multiple interface Hello,Sample{
public String dispMsg()
 Your class can implement more {
than one interface, so return "Hello World!";
}
 the implements keyword is public int sum(int x, int y)
followed by a comma-separated {
return x+y;
list of the interfaces implemented
}
by the class. public int prod(int x, int y)
{
return x*y;
}
 public static void main(String args[])
{
int x=10,y=5;
MultipleInterface xx=new MultipleInterface();
System.out.println(xx.dispMsg());
System.out.println(xx.prod(x,y));
System.out.println(xx.sum(x,y));
}}

8
 Extending interface?
 Eg:
 An interface can extends
another interface like the way to interface Vehicle{
the class extends another class public void displayColor();
using extends keyword.
}
 The child interface inheritance
the method and member interface Car extends Vehicle{
variable of parent interface. public void showMiledge();
 By convention, }
the implements clause follows
the extends clause, if there is
one.

9
Multiple inheritance-interface  class maindemo {
public static void main(String arg
 interface car
s[]){
{int speed=90;
System.out.println("Vehicle");
public void distance();
Vechicle v1=new Vehicle();
}
v1.distance();
 interface bus v1.speed();
{ int distance=100; }
public void speed();
}
}
 class vehicle implements car,bus{
public void distance()  Output?
{
int distance=speed*100;
System.out.println("distance travelle
d is"+distance);
}
public void speed() {
int speed=distance/100;}
10
}
 3. Polymorphism
Polymorphism is achieved by redefining or
overriding routines. Be careful not to confuse
overriding and overloading.
 Overloading arises when two or more functions share a name.
 These are disambiguated by the number and types of the
arguments.
 Overloading means the use of the same name in the same
context for different entities with completely different
definitions and types.

11
 Cont…
 How Polymorphism support in Java?
 Java has excellent support of polymorphism in terms of method
overloading (compile time polymorphism) and method overriding
(runtime polymorphism).
 Function overloading provides a way to have multiple
functions with the same name.( The compiler selects the
appropriate version. This process is called function resolution.)

Polymorphism:-
 “many forms”, refers to identically named ,methods that have
different behavior depending on the type of the object they
refer.
 Helps to design and implement systems that are more easily
extensible.

12
 Method Overloading
 Static Binding or compile time polymorphism
 Early binding:-choosing the method in normal way during compilation
time
 If a class have multiple methods by same name but different
parameter is known as Method Overloading.
 appear in the same class or a subclass
 have the same name but,
 have different parameter lists, and,
 can have different return types

Advantage of Method Overloading

 Method overloading increases the readability of program.

How to overload method

 There are two way to overload the method.
 By changing number of arguments.
 By changing the data type of arguments.
 Note: In Java, Method overloading is not possible with changing
13
return type of methods.
 Example:
 public class Sample{
public void sum(int a, int b){
System.out.println(a+b);
}
public void sum(int a, int b, int c){
System.out.println(a+b+c);
}
public static void main(String args[]){
Sample st = new Sample();
st.sum(10,20);
st.sum(10,20,30);
}}
 Check by changing Data types of arguments?
14
 Method Overriding
 Dynamic Binding or Runtime Polymorphism)
 Having the same method in the subclass as declare in parent class
is known as method overriding.
 object type (NOT reference variable type) determines which
overriden method will be used at runtime
 overriding method MUST have the same argument list (if not, it
might be a case of overloading)
 abstract methods MUST be overridden
 final methods CANNOT be overridden
 static methods CANNOT be overridden
 constructors CANNOT be overridden

15
 (cont’d)

Advantages of Method Overriding:

 Time to invest method signature is reduced
 Different functionality in both super class and sub class by sharing
same signature
 The functionality can be enhanced
 The behavior can be replaced in the sub class
 Method Overriding is used for Runtime Polymorphism

16
 Example  void display(){
 class superCls{ System.out.println("super y = " +y);
int y; System.out.println("sub z = " +z);
superCls(int y) { }
this.y=y;
} }
void display(){  public class Test{
System.out.println("super y = " +y); public static void main(String[] args){
} subCls obj1 = new subCls (500,300);
obj1.display();
}
}
 class subCls extends superCls{
}
int z;
Look the overriding method?
subCls(int z , int y){
super(y);
this.z=z;
}
17
 4. Abstract Class?
 An abstract class is a class that cannot be instantiated—
we cannot create instances of an abstract class.
 One or more methods may be declared, but not defined.
(The programmer has not yet written code for a few
methods).
 The declared methods and classes have the keyword
abstract in their signature.
An abstract class can have both abstract and non-abstrac
t methods
Rule: An abstract class can have zero or more abstract
methods
Abstract methods need to be defined in concrete subclas
ses (classes that can be instantiated) 18
 Example
 public String getLastName(){
 public abstract class Employee1 {
return lastName;
private String firstName;
private String lastName; }
 public Employee1( String first, String  public String toString(){
last ) { return firstName + ' ' + lastName;
firstName = first; }
lastName = last;  public abstract double
} earnings();
 public String getFirstName(){ }
return firstName;
}

19
 Example
 public double earnings()
 public final class Boss extends
Employee1 { {
private double weeklySalary;
return weeklySalary;
 public Boss( String first, String last,
}
double salary ){
super( first, last ); // call superclass
constructor
setWeeklySalary( salary );  // get String representation of
Boss's name
}
 public String toString()
public void setWeeklySalary( double
salary ) { {
weeklySalary = ( salary > 0 ? salary : 0 ); return "Boss: " +
} super.toString();
}

} //
20
 Example
 public void setHours( double
 public final class HourlyWorker
hoursWorked ){
extends Employee1 {
hours = ( hoursWorked >= 0 &&
private double wage; // wage per hour
hoursWorked < 168 ?
private double hours; // hours worked for
week hoursWorked : 0 );

 public HourlyWorker( String first, }

String last,  public double earnings() {
double wagePerHour, double hoursWorked
return wage * hours; }
){
super( first, last ); // call superclass  public String toString(){
constructor return "Hourly worker: " +
setWage( wagePerHour ); super.toString();
setHours( hoursWorked );
}
}
}
 public void setWage( double
wagePerHour )
{ wage = ( wagePerHour > 0 ?
wagePerHour : 0 );
} 21
 Example boss.toString() + " earned $" +
 public class Test { precision2.format( boss.earnings() ) +
"\n";
 public static void main( String  // Employee reference to an
args[] ){ HourlyWorker
 Employee1 employee; // superclass  employee = hourlyWorker;
reference--imposible to instantiate coz output += employee.toString() + "
abstract earned $" +
String output = ""; precision2.format(
 Boss boss = new Boss( "John", "Smith", employee.earnings() ) + "\n" +
800.0 ); hourlyWorker.toString() + " earned $"
 HourlyWorker hourlyWorker = new +
HourlyWorker( "Karen", "Price", 13.75, 40 ); precision2.format(
DecimalFormat precision2 = new hourlyWorker.earnings() ) + "\n";
DecimalFormat( "0.00" ); JOptionPane.showMessageDialog(
// Employee reference to a Boss null, output,
 employee = boss; "Demonstrating Polymorphism",
output += employee.toString() + " earned $" + JOptionPane.INFORMATION_MESSA
GE );
precision2.format( employee.earnings() ) + "\n"
+ System.exit( 0 );
}
}
22
 Exercise
Define three classes show how polymorhism achieved
 Animal (name, location)..abstract
 Dog (name, makesound())..concrete
 Cat (name,makesound())..concrete

23
 Exception Handling
Introduction

 An Error "indicates serious problems that a reasonable application

should not try to catch."
 An Exception "indicates conditions that a reasonable application
might want to catch.
 An exception is an indication of a problem that occurs during a program’s
execution.

 The name “exception” implies that the problem occurs infrequently—

if the “rule” is that a statement normally executes correctly, then the
“exception to the rule” is that a problem occurs.
 Exception handling enables you to create
 applications that can resolve (or handle) exceptions.
24
 Basic idea:
 Helps to write a robust and fault-tolerant programs
.

25
 Exception Hierarchy
The Java exception hierarchy contains hundreds of
classes.

26
 Cont…
java.lang.Object
java.lang.Throwable
 ava.lang.Exception
 java.lang.ClassNotFoundException
 java.io.IOException
 java.io.FileNotFoundException
 java.lang.RuntimeException
 java.lang.NullPointerException
 ava.lang.IndexOutOfBoundsException
 java.lang.ArrayIndexOutOfBoundsException
 java.lang.Error
 java.lang.VirtualMachineError
 java.lang.OutOfMemoryError

27
 Types of Exception
There are two types of exceptions:
 checked exceptions
 are checked at compile-time, It means
 if a method is throwing a checked exception then it should handle the
exception using try-catch block or it should declare the exception
using throws keyword, otherwise the program will give a compilation
error.

 Eg: SQLException,IOException,ClassNotFoundException
 unchecked exceptions-(sub class of RuntimeException class).
 are checked at runtime,It means
 if your program is throwing an unchecked exception and even if you
didn’t handle/declare that exception, the program won’t give a
compilation error.
 Most of the times these exception occurs due to the bad data provided
by user during the user-program interaction.
 It is up to the programmer to judge the conditions in advance, that can
cause such exceptions and handle them appropriately.
 Eg: ArithmeticException, NullPointerException,ArrayIndexOutOfBoundsException28
 Examples:  public static void main(String
args[]){
 class Example {  try{
public static void main(String  int arr[] ={1,2,3,4,5};
args[]) { System.out.println(arr[10]);
}
int arr[] ={1,2,3,4,5};  catch(ArrayIndexOutOfBounds
System.out.println(arr[10]); Exception e){
}}  System.out.println("The specified
index does not exist " +
What type of exception? "in array. Please correct the
error.");
 }
 }

29
 How Exceptions are handled?
 Using Try-Catch block
 try{
 statements
 resource-acquisition statements
 } // end try
 catch ( AKindOfException exception1 )
 {exception-handling statements
 }
 catch ( AnotherKindOfException exception2 )
 {exception-handling statements
 }
 finally
 {
 statements
 resource-release statements
 }
30
Cont…

31
 Cont…
 1. Try
 a try block, which encloses the code that might throwan
exception
 and the code that should not execute if an exception occurs
 the remaining code in the try block will be skipped if the
exception occurs.

 A try block consists of the keyword try followed by a block of

code enclosed in curly braces ({})
 2. throws clause
 specifies the exceptions the method throws. This clause appears
after the method’s parameter list and before the method’s body.
 It contains a comma-separated list of the exceptions that the
method will throw if a problem occurs
 Eg-public static void main(String args[]) throws SQLException
32
 Cont…
Throw vs Throws
 Throws clause is used to declare an exception and thow keyword
is used to throw an exception explicitly.
 Checked exception can only be propagated with throws.
 Throws is followed by a Class but throw is followed by an instance
 Throws is used with the method signature but throw is used inside a
method
 You cannot throw multiple exceptions but possible to declare
multiple exceptions using throws
 Without the throws clause in the signature the Java JVM compiler
does not know what to do with the exception.
 The throws clause tells the compiler that this particular exception
would be handled by the calling method.
 Eg:
 ArithmeticException exp = new ArithmeticException(); throw exp;
 Public void fun() throws IOException, ArithmeticException,
33
 Cont…
3. A catch block/ exception handler )
catches /receives and handles an exception.
 A catchblock begins with the keyword catch and is
followed by a parameter in parentheses (called the
exception parameter, )and a block of code enclosed in
curly braces.
At least one catchblock must imme-diately follow the
try block. Each catchblock specifies in parentheses an
exception-parameter that identifies the exception type
the handler can process
Eg- catch (SQLException ex ){}

34
 Cont…
4. Finally block
Programs that obtain certain types of resources must
return them to the system explicitly,to avoid so-called
resource leaks .
 In programming languages such as C and C++, the
most common kind of resource leak is a memory leak.
 Java performs automatic garbage collec-tion of
memory no longer used by programs, thus avoiding
most memory leaks. However,

35
 Example
 import java.util.*;
 import java.io.*;
 public class ExceptionEg {
 // demonstrates throwing an exception when a divide-by-zero occurs
 public static int quotient( int numerator, int denominator )
{
 return numerator / denominator; // possible division by zero
 } // end method quotient
 public static void main( String args[] )
 {
 Scanner scanner = new Scanner( System.in ); // scanner for input
 boolean continueLoop = true; // determines if more input is needed

36
 Cont…
 do
{
 try // read two numbers and calculate quotient
 {
 System.out.print( "Please enter an integer numerator: " );
 int numerator = scanner.nextInt();
 System.out.print( "Please enter an integer denominator: " );
 int denominator = scanner.nextInt();
 int result = quotient( numerator, denominator );
 System.out.printf( "\nResult: %d / %d = %d\n" ,
numerator,denominator, result );
 continueLoop = false; // input successful; end looping
 } // end try 37
 Cont…
 catch ( InputMismatchException inputMismatchException )
{
 System.err.printf( "\nException: %s\n",inputMismatchException );
 scanner.nextLine(); // discard input so user can try again
 System.out.println("You must enter integers. Please try again.\n" );
 } // end catch
 catch ( ArithmeticException arithmeticException )
 {System.err.printf( "\nException: %s\n", arithmeticException );
 System.out.println("Zero is an invalid denominator. Please try
again.\n" );
 } // end catch
 finally {System.out.println("finished");}
 } while ( continueLoop );} } 38
 Summary
 Interfaces may specify but do not implement methods.
 A class that implements the interface must implement all its
methods.
 An interface, similar to an abstract class, cannot be instantiated
 An interface has no constructors, only constants and method
declarations.
 Classes implement interfaces using the keyword implements
 Interface functions should be public and abstract.
 Interface fields should be public ,static and final.
 If you define a public interface with name myInterface the
java file should be named as myInterface.java (Similar to public
class definition rules).
 An Interface can extends one or more interfaces.
 You can define a reference of type interface but you should
assign to it an object instance of class type which implements
that interface.
 Final or static classes cannot be overridden and final class
can’t be a super class because it can’t be modified/inherited
39