Explain dynamically bound and static methods [closed]

Question

I"m a little confused on how private methods can be static and but public must be dynamically bound.

Answer 1

Dynamic binding means that the decision as to which code is run is made at runtime. This is the basis of polymorphism.

Public, package access and protected methods are dynamically bound. Subclasses can override the methods and provide alternative implementations. Private methods cannot be overridden, so dynamic binding is not needed for them.

Static methods are not dynamically bound (the clue's in the name) as they are defined on the class itself rather than being unique to each object.

Answer 2

Dynamic Binding or Late Binding

Dynamic Binding refers to the case where compiler is not able to resolve the call and the binding is done at runtime only. Let's try to understand this. Suppose we have a class named SuperClass and another class named SubClass extends it. Now a SuperClass reference can be assigned to an object of the type SubClass as well. If we have a method (say someMethod()) in the SuperClass which we override in the SubClass then a call of that method on a SuperClass reference can only be resolved at runtime as the compiler can't be sure of what type of object this reference would be pointing to at runtime.

...
SuperClass superClass1 = new SuperClass();
SuperClass superClass2 = new SubClass();
...

superClass1.someMethod(); // SuperClass version is called
superClass2.someMethod(); // SubClass version is called
....

Here, we see that even though both the object references superClass1 and superClass2 are of type SuperClass only, but at run time they refer to the objects of types SuperClass and SubClass respectively.

Hence, at compile time the compiler can't be sure if the call to the method someMethod() on these references actually refer to which version of the method - the super class version or the sub class version.

Thus, we see that dynamic binding in Java simply binds the method calls (inherited methods only as they can be overriden in a sub class and hence compiler may not be sure of which version of the method to call) based on the actual object type and not on the declared type of the object reference.

---

Static Binding or Early Binding

If the compiler can resolve the binding at the compile time only then such a binding is called Static Binding or Early Binding. All the instance method calls are always resolved at runtime, but all the static method calls are resolved at compile time itself and hence we have static binding for static method calls. Because static methods are class methods and hence they can be accessed using the class name itself (in fact they are encourgaed to be used using their corresponding class names only and not by using the object references) and therefore access to them is required to be resolved during compile time only using the compile time type information. That's the reason why static methods can not actually be overriden. Read more - Can you override static methods in Java?

Access to all the member variables in Java follows static binding as Java doesn't support (in fact, it discourages) polymorphic behavior of member variables.

[Apart from this discussion, you can not override static (as mentioned by the above link), private and final methods in Java.]