Introduction to Dynamic Binding in Java

“Dynamic” means “run time”, and “binding” means

“association”. So the term dynamic binding indicates run
time association of objects by java virtual machine. Here
we will see how Java achieves dynamic binding in run
time, which means before the code’s final running but
after compilation.
Syntax: For dynamic binding in Java, you should follow
the basic syntax of java with annotations. You may use
@Override annotation here to point out which method
we want to override specifically.

Introduction to Dynamic Binding in Java

“Dynamic” means “run time”, and “binding” means
“association”. So the term dynamic binding indicates
run time association of objects by java virtual machine.
Here we will see how Java achieves dynamic binding in
run time, which means before the code’s final running
but after compilation.
Syntax: For dynamic binding in Java, you should
follow the basic syntax of java with annotations. You
may use @Override annotation here to point out which
method we want to override specifically.
How Dynamic Binding Works in Java?
Runtime polymorphism works in Java by method
overriding. Method overriding happens when objects
have the same method name and arguments and type as
of their parent class but with different functionality. If a
child class has that type of method in it, we call it an
overridden method.
Why is it called dynamic binding?
Reason being named so, due to the fact that the
functionality of the method is dynamically decided in
run time as per the object by JVM. It is also referred to
as “Run time Polymorphism”. when we call an
overridden method of child class through its parent type
reference (this phenomenon in java is referred to as
“Upcasting”), then the type of the object indicates
which method or functionality will be invoked. Making
of this decision happens during runtime by JVM after
the compilation of code. Hence it is called run time
polymorphism. It is also called “Late binding”, because
binding of method and object, which means the
functionality of which object’s method will be
displayed, is decided late, i.e. after compilation.
Rules Regarding Dynamic Binding
• Methods or functions of child and parent class must

have the same name.

• Methods or functions of child and parent class must

have the same parameter.

• The inheritance relationship is mandatory (IS-A

relationship).
Limitations in Dynamic Binding
• You cannot override the private methods of a

parent class.
• You cannot override Final methods.

• You cannot override static methods.

Examples to Implement Dynamic Binding
We will discuss some code examples of Dynamic
Binding here:
Example #1
In this example, we will show how the method locate ()
is displaying different messages depending on which
type of object it is associated with. When it is
associated with the “Continent” type, it is showing
messages from a parent class. When it is associated
with the “SubContinent” type, it shows messages from
the child class.
Popular Course in this category

Code:
class Continent {
public void locate () {
System.out.println("We are in Continent");
}
}
class SubContinent extends Continent {
@Override
public void locate () {
System.out.println("We are in SubContinent");
}
}
public class DynamicBinding {
public static void main(String args[]) {
Continent superObject = new Continent ();
superObject.locate(); //method of super class or parent
class is called
SubContinent subObject = new SubContinent (); //
upcasting
subObject.locate();//method of sub class or child class
is called by Parent reference, this is called "Dynamic
Binding"
SubContinent subObject2 = new SubContinent ();
subObject2.locate(); //method of sub class or child class
is called
}
}

Example #2
Let us take an example of dynamic binding in the case
of multilevel inheritance. In this example, we have two
levels of inheritance is taken into account. In this
example, we will show how the method identifies () is
displaying different messages depending on which type
of object it is associated with. When it is associated
with the “Computer” type, it is showing messages from
a parent class. When it is associated with the “Desktop”
type, it shows messages from its child class. Again in
the second level of inheritance, when associated with
the “Laptop” type, it shows messages from its child
class of its parent, the “Desktop” class.
Code:
class Computer {
void identify() {
System.out.println("This is Computer");
}
}
class Desktop extends Computer {
void identify (){
System.out.println("This is Desktop");
}
}
class Laptop extends Desktop {
void identify (){
System.out.println("This is Laptop");
}
}
public class DynamicBinding {
public static void main(String args[]){
Computer superObject=new Computer ();
Computer subObject=new Desktop (); // // upcasting :
first level of heritance
Computer babyObject=new Laptop (); // // upcasting :
second level of heritance
superObject.identify ();
subObject.identify (); //run time polymorphism
happening in first level of heritance
babyObject.identify (); //run time polymorphism
happening in second level of heritance
}
}

Example #3
Let us take another example of run time polymorphism
in the case of multilevel inheritance. In this example,
we have three levels of inheritance is taken into
account. In this example, we will show how the method
feature () is displaying different features depending on
which type of object it is associated with. When it is
associated with the “Cosmetics” type, it is showing
messages from a parent class. When it is associated
with the “Perfume” type, it shows messages from its
child class. Again in the second level of inheritance,
when associated with the “Deo” type, it shows
messages from its child class of its parent, the
“Perfume” class. Again in the third level of inheritance,
when associated with the “DeoStick” type, it shows
messages from its child class of its parent, the “Deo”
class.
Code:
class Cosmetics{
void feature() {
System.out.println("Cosmetics are expensive");
}
}
class Perfume extends Cosmetics {
void feature(){
System.out.println("Perfume is soothing");
}
}
class Deo extends Cosmetics {
void feature(){
System.out.println("Deo is sometimes better than
perfume");
}
}
class DeoStick extends Deo{
void feature(){
System.out.println("DeoStick is very handy");
}
}
public class RunTimePolymorphism {
public static void main(String args[]){
Cosmetics superObject=new Cosmetics ();
Cosmetics subObject=new Perfume(); // child object
type : first level of heritance
Cosmetics sub2Object=new Deo(); // child object type :
second level of heritance
Cosmetics sub3Object=new DeoStick(); // child object
type : third level of heritance
superObject.feature();
subObject.feature(); //run time polymorphism
happening in first level of heritance
sub2Object.feature(); //run time polymorphism
happening in second level of heritance
sub3Object.feature(); //run time polymorphism
happening in third level of heritance
}
}

Conclusion
This concludes our learning of the topic “Dynamic
Binding in Java”. Write yourself the codes mentioned in
the above examples in the java compiler and verify the
output. Learning of codes will be incomplete if you will
not write code by yourself.

Static Binding VS Dynamic Binding

Let’s get started with the question – What is Binding?

Binding refers to the linking between the function call

and the function definition.
In your code, at any point of time when a function is
called, then the program control binds to the address in
memory where the function has been defined.

Static Binding
Static binding happens at compile-time, i.e., the function
call and the function definition are linked during the
compile time itself. So, it is also called early binding.
This is because all the information needed to associate
the function call to its definition is available at the
compile time.
When does static binding take place?
Static binding happens by default for any normal
function calls in the program. It also occurs during
function overloading and operator overloading.
The binding of static, private and final methods is
always compile-time. Why? This is because the type of
class is determined at the compile-time and hence
binding happens then and there.
Let’s look at an example to understand better –

Java code for demonstrating Static binding:

class add {

public int sum(int a, int b) {

return a + b;

public int sum(int a, int b, int c) {

return a + b + c;

}
}
public class static_binding {
public static void main(String args[]) {
add a1 = new add();
int a, b, c;
a = 10;
b = 20;
c = 30;
System.out.println(a1.sum(a, b));
System.out.println(a1.sum(a, b, c));

}
}
Output:
30
60

Dynamic Binding
Dynamic binding takes place during run time based on
the type of object. Since it is delayed till the run time, it
is also called late binding or runtime binding. When the
compiler cannot determine all the information required
to resolve a function call during compile time, these
function calls are not bound until run time.
When does dynamic binding take place?
It can be achieved with the use of virtual functions in
C++ and overridden methods in Java.
Example of Dynamic binding:
Java code for demonstrating Dynamic binding:
class Human {
// Overridden Method
 public void walk() {
System.out.println("Human walks");
}
}

class Boy extends Human {

// Overriding Method
public void walk() {
System.out.println("Boy walks");
}

public class dynamic_binding {

public static void main(String args[]) {

// Reference is of Human type and object is Boy type

Human obj = new Boy();
obj.walk();// calls function of Boy class

// Reference is of Human type and object is of

Human type Human
obj = new Human();
obj.walk();// calls function of Human class

}
}
Output:
Boy walks
Human walks
Static Vs Dynamic Binding
Static Binding Dynamic Binding
It happens at the compile
It happens at the run time.
time.
It is also called early
It is also called late binding.
binding.
When all the
information needed to When the compiler cannot
call a function is determine all the information
available at the compile to resolve the function call,
time, static binding dynamic binding occurs.
occurs.
It can be achieved
during normal function
It is achieved with the use of
calls, function
virtual functions.
overloading and
operator overloading.
Execution becomes
faster than dynamic As the function call is
binding because the resolved at run time,
function call gets sometimes it leads to slower
resolved before run code execution.
time.
It provides less It provides more flexibility as
flexibility compared to different types of objects at
the dynamic binding. runtime can be handled by a
 single function call making
the source code more
readable.

What is static and dynamic binding in OOP?

n static binding, function calls are resolved at compile
time by the compiler itself. The binding of all the static
and private functions/methods of a class happens at
compile time.
In dynamic binding, function calls are resolved at run
time. Function overriding in OOP is possible due to
dynamic/late binding.
What is an example of dynamic binding?
Function overriding is an example of dynamic binding.
Can we override the static method?
No, the static methods cannot be overridden because
static methods are bound at compile time using static
binding. Example – If a derived class D defines a static
method with the same signature as the static method
defined in the base class, the base class method gets
executed. Hence, no overriding takes place.
What are dynamic binding and message passing?
Dynamic binding links the function call to the function
body/definition at run time according to the object type.
In contrast, message passing is a method of exchanging
information between objects in Object-oriented
programming.