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.
4.8 (10,660 ratings)
View Course
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
}
}
Output:
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
}
}
Output:
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
}
}
Output:
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.
Recommended Articles
This is a guide to Dynamic Binding in Java. Here we discuss the syntax, rules, limitations, and examples of dynamic binding in java. You may also look at the following articles to learn more –
