Difference Betwixt Static As Well As Dynamic Binding Inward Java

When y'all telephone phone a method inwards Java, it is resolved either at compile fourth dimension or at runtime, depending upon whether it's a virtual method or a static method. When a method telephone phone is resolved at compile time, it is known every bit static binding, acre if method invocation is resolved at runtime, it is known every bit Dynamic binding or Late binding. Since Java is an object-oriented programming linguistic communication in addition to yesteryear virtue of that it supports Polymorphism. Because of polymorphism, a reference variable of type Parent can concord an object of type Child, which extends Parent. Now if y'all telephone phone a virtual method (not private, lastly or static) on this object, in addition to then Compiler tin non uncovering actual method, because it could live the one, which is defined inwards the Parent class, or the ane which Child has overridden. This telephone phone tin exclusively live resolved at runtime when the actual object is available. That's why this is known every bit runtime or dynamic binding.

On the other hand, private, static and final methods are resolved at compile time, because compiler knows that they can't live overridden in addition to exclusively possible methods are those, which are defined within a class, whose reference variable is used to telephone phone this method.

This is known every bit static or compile fourth dimension binding, all private, static and final methods are resolved using static binding. This concept is besides closely related to method overloading in addition to method overriding.

As dynamic binding happens when method overriding is possibility in addition to overloaded method calls are resolved at compile time, because they are ever defined inwards same class.

In this article, nosotros volition larn few to a greater extent than difference betwixt Static in addition to Dynamic Binding inwards Java, but earlier this let's meet couplet of examples of static in addition to dynamic binding :

Static vs Dynamic Binding inwards Java

Following Java plan volition assistance y'all to sympathize deviation betwixt static in addition to dynamic binding inwards Java. In below example, nosotros convey ii degree Parent and Child, where Child is sub-class of Parent. In superclass nosotros convey iii methods, ane private, ane static in addition to ane virtual, similarly on shaver degree nosotros convey defined all those iii methods, amongst exact same refer in addition to syntax.

Since private in addition to static method tin non live overridden, they only enshroud super degree implementation. Only virtual method tin live overridden in addition to those volition live resolved using dynamic binding.  Test code is written inwards a examine degree called, HelloAndroid, where a reference variable of type Parent is pointing to object of Child class.

This reference variable is in addition to then used to telephone phone static method whoAmI(), in addition to virtual method whoAreYou(), defined on both super in addition to sub class, in addition to since nosotros tin non telephone phone soul method from exterior the class, it is  internally called within virtual method. Now let's analyse output of get-go telephone phone  p.whoAmI()  , it prints "Inside static method, Parent#whoAmI()" which way static method from Parent degree is invoked in addition to object is non used inwards method resolution, exclusively type is used. This is example of static binding inwards Java.

On the other hand, telephone phone to virtual method i.e. p.whoAreYou() prints ii lines Child#who in addition to Child#whoAreYou, which way virtual method from subclass is invoked, which besides invoked soul method from sub-class, non from super class, because its non accessible. This is an instance of dynamic binding inwards Java, in addition to it uses actual object for method resolution.

/**  * Java plan to demonstrate deviation betwixt static in addition to dynamic binding inwards Java.  * Static method are resolved at compile time, yesteryear Type of reference variable,  * acre Virtual methods are resolved at runtime, depending upon actual object.  *  * @author WINDOWS 8  *  */ public class HelloAndroid {   public static void main(String args[]) {      Parent p = new Child();        p.whoAmI(); // static method, resolved at compile time   p.whoAreYou(); // virtual method, runtime resolution  }    }  class Parent {    private void who(){   System.out.println("Inside soul method Parent#who()");  }    public static void whoAmI(){   System.out.println("Inside static method, Parent#whoAmI()");  }    public void whoAreYou(){   who();   System.out.println("Inside virtual method, Parent#whoAreYou()");  } } 

class Child extends Parent{    private void who(){   System.out.println("Child#who()");  }      public static void whoAmI(){   System.out.println("Child#whoAmI()");  }    @Override  public void whoAreYou(){   who();   System.out.println("Child#whoAreYou()");  } }  Output: Inside static method, Parent#whoAmI() Child#who() Child#whoAreYou()

In brusque next are key differences betwixt Static in addition to Dynamic binding inwards Java :

1) Static binding is resolved at compile time, acre Dynamic binding is resolved at runtime.

2) Static binding exclusively uses Type information, in addition to method resolution is based upon type of reference variable, acre dynamic or belatedly binding resolves method based upon actual object.

3) In Java programming language, private, static and final method are resolved using static binding, acre exclusively virtual methods are resolved using dynamic binding.

4) True Polymorphism is achieved using dynamic binding, in addition to its key of many blueprint principles e.g. Strategy pattern, Open unopen blueprint pattern etc.

That's all almost difference betwixt static in addition to dynamic binding inwards Java. You tin play some this code to endeavor dissimilar combination of method calling e.g. calling a sub degree method using Super degree object or vice-versa. Let me know if y'all convey inquiry related to agreement static or dynamic binding inwards Java.

Further Learning
Data Structures in addition to Algorithms: Deep Dive Using Java
Java Fundamentals: The Java Language
Complete Java Masterclass