• Skip to primary navigation
  • Skip to main content
  • Skip to primary sidebar
  • Skip to footer
  • Core Java
  • Design Patterns
  • JSP
  • Servlets
  • Building Tools
  • jQuery
  • Spring
  • Hibernate
  • Mongo DB
  • More
    • HTML
    • SCJP
    • AJAX
    • UML
    • Struts
    • J2EE
    • Testing
    • Angular JS

J2EE Reference

  • Home
  • About Us
    • Java Learning Centers
  • Contact Us

Dynamic Binding and Static Binding in Java

June 26, 2012 By j2eereference Leave a Comment

Dynamic and static binding

Today, I’ll be sharing one of the important existing facts in Java, which I personally feel that every Java Professional should be aware of as it helps us to understand the Java code to locate and debug / troubleshoot bugs or issues we may come across while running a Java program.

Dynamic Binding

In Java, we can assign derived class object to a base class variable. For example, if you have a class named Vehicle from which you derived the class Car,

Vehicle myVehicle = new Car();

The variable on the left is an object of class Vehicle, but the object on the right is type Car. It will compile and run successfully but reverse is not possible.

If the Car class has a method that is the same as a method in the Vehicle, then the method in the derived Car class will be called.
For instance, if both classes define a method called show(), and you do this:

myVehicle.show();

In this case,the method of show() in the Car class will be called.Even though you are using an Vehicle variable type to call the method show(), the method of show() in the method of Vehicle class won’t be executed. Instead, it is the method of show() in the Car class that will be executed.

The type of the object that is assigned to the Vehicle variable determines the method that is called. So, when the compiler scans the program and sees a statement like this:

myVehicle.show();
It knows that myVehicle is of type Vehicle, but the compiler also knows that myVehicle can be a reference to any class derived from Vehicle. Therefore, the compiler doesn’t know what version of show() that statement is calling. It’s not until the assignment:

Vehicle myVehicle = new Car();

After executing the method of show() is determined. Since the assignment doesn’t occur until runtime, it’s not until runtime that the correct method of show() is known. That is known as “dynamic binding” or “late binding”: it’s not until your program performs some operation at runtime that the correct version of a method can be determined. In Java, most uses of inheritance involve dynamic binding.

Static Binding

It occurs when the compiler determines the correct method called from superclass or subclass something during compile time ,i.e. before the program is executed.

If both the Vehicle class and the Car class have a member variable with the same name, it’s the base class version that is used.

Vehicle myVehicle = new Car();

Both the Vehicle and Car classes have a String member variable ‘type’, then if you do this:

String str = myVehicle.type;

The value of ‘type’ can be fully determined by the compiler. Because polymorphism is not allowed for member variables, that statement is referring to the value of  ‘type’ in the Vehicle class–not the Car’s value for ‘type’. The result is: with member variables, it’s the type of the variable (e.g. myVehicle) that determines which version is called–not the type of the object the variable refers to (e.g. Car).

That means if both the Vehicle class and the Car class have a member variable with the same name, it’s the base class version that is used.

When the compiler is able to find out the correct version of something during compilation, that is known as “static binding or early binding”.

Below is an example of both dynamic and static binding:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.j2eereference.coreJava;
class Vehicle
{            
        public String type = "Sedan";
 
               public void display()
               {
                    System.out.println("The vehicle is: " + type);
               }
}
class Car extends Vehicle
{              
       public String type;  //same member variable name as in base class
 
               public Car(String type)
               {    
                    this.type = type;
               }
               public void display()  //same method signature as in base class            
              {
                System.out.println("The car is: " + type);
              }
}
public class DemoBindingExample
{              
           public static void main(String[] args)
               {                          
                    Vehicle honda = new car("Accord");
                    honda.display(); // "The car is: Accord"  (dynamic binding)
                    System.out.println("The type is: " + honda.type);
                   //"The type is: Sedan" (static binding)            
              }
}

Related Posts

  • Busy Spinning in mutithreading
  • Implementing queue in java
  • TreeSet vs ConcurrentSkipListSet
  • How to create immutable class?
  • Implementing Stack in java
  • What is ReentrantLock?
  • What is Semaphore in java
  • Why AtomicInteger class
  • What is CyclicBarrier?
  • CountDownLatch in java

Filed Under: Core Java

Reader Interactions

Leave a Reply Cancel reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Primary Sidebar

FOLLOW US ONLINE

  • View J2eereference-166104970118637’s profile on Facebook
  • View j2eereference’s profile on Twitter
  • View j2eereference’s profile on LinkedIn

Subscribe by email

Recent posts

  • What is parallel Stream
  • reduce method of the Stream class
  • Difference between the findFirst() and findAny() method
  • intern() method of String class
  • SOLID – Five principles of object-oriented software design
  • Java Coding Best Practices
  • How to use lambda expression effectively
  • Enhanced pseudo-Random Number Generators in java17
  • How to use Foreign-Memory Access API
  • Pattern Matching for instanceof
  • Text Blocks – Feature added in Java17
  • Record – The new feature added in java 17
  • What is Sealed Class
  • Features added in Java 17
  • Java Buzzwords

Footer

Core Java
Design Patterns
JSP
Servlets
HTML
Building Tools
AJAX
SCJP
jQuery
Testing
Spring
UML
Struts
Java Centers
Java Training
Home
About Us
Contact Us
Copyright © j2eereference.com. All right reserved.