Static Vs. Dynamic Binding in Java

Static Vs. Dynamic Binding in Java

Static binding (also known as early binding) and dynamic binding (also known as late binding) are two important concepts in object-oriented programming, including Java. They refer to the resolution of method calls or method invocations during the program's execution. Let's explore the differences between static and dynamic binding in Java:

  1. Static Binding (Early Binding):

    • Static binding refers to the process of binding a method call to a specific method implementation at compile time, based on the type of the reference variable.
    • It occurs when the type of the object is determined at compile time, and the compiler knows which method implementation to invoke based on the reference type.
    • Static binding is also known as compile-time binding because it is resolved at compile time.
    • It is commonly used with method calls involving static methods, private methods, final methods, and overloaded methods (when the method being called is determined based on the reference type, not the actual object type).

    Example of static binding:

    class Parent { void print() { System.out.println("Parent's print method"); } } class Child extends Parent { void print() { System.out.println("Child's print method"); } } public class Main { public static void main(String[] args) { Parent obj = new Child(); obj.print(); // Static binding based on reference type } }

    In this example, the obj.print() call is resolved at compile time based on the reference type (Parent), so it invokes the print method of the Parent class.

  2. Dynamic Binding (Late Binding):

    • Dynamic binding refers to the process of binding a method call to a specific method implementation at runtime, based on the actual object's type.
    • It occurs when the type of the object is determined at runtime, and the JVM (Java Virtual Machine) selects the appropriate method implementation to invoke based on the actual object type.
    • Dynamic binding is also known as runtime binding because it is resolved at runtime.
    • It is commonly used with method calls involving overridden methods (when the method being called is determined based on the actual object's type).

    Example of dynamic binding:

    class Parent { void print() { System.out.println("Parent's print method"); } } class Child extends Parent { void print() { System.out.println("Child's print method"); } } public class Main { public static void main(String[] args) { Parent obj = new Child(); // Upcasting obj.print(); // Dynamic binding based on actual object type } }

    In this example, the obj.print() call is resolved at runtime based on the actual object's type (Child), so it invokes the print method of the Child class.

Dynamic binding is a fundamental feature of polymorphism in Java, allowing objects of different subclasses to be treated uniformly when calling overridden methods defined in their common superclass. It is a key concept in achieving flexibility and extensibility in object-oriented programming.

More Tags

markdown django-cache wolfram-mathematica azure-rm-template gpgpu asp.net-mvc-routing matplotlib-animation project-reference mysql-5.0 xcode8

More Java Questions

More Retirement Calculators

More Entertainment Anecdotes Calculators

More Investment Calculators

More Biochemistry Calculators