Interested to Buy Any Domain ? << Click Here >> for more details...
Answer Posted / eknath wagadre
I think Sadikhasan Palsaniya answer is wrong....
Well... the answer is NO!!!! Why it's No...
if you think from the perspective of how an overriden method
should behave in Java. But, you don't get any compiler error
if you try to override a static method. That means, if you
try to override, Java doesn't stop you doing that; but you
certainly don't get the same effect as you get for
non-static methods. Overriding in Java simply means that the
particular method would be called based on the run time type
of the object and not on the compile time type of it (which
is the case with overriden static methods). Okay... any
guesses for the reason why do they behave strangely? Because
they are class methods and hence access to them is always
resolved during compile time only using the compile time
type information. Accessing them using object references is
just an extra liberty given by the designers of Java and we
should certainly not think of stopping that practice only
when they restrict it :-)
Example: let's try to see what happens if we try overriding
a static method:-
class SuperClass{
......
public static void staticMethod(){
System.out.println("SuperClass: inside staticMethod");
}
......
}
public class SubClass extends SuperClass{
......
//overriding the static method
public static void staticMethod(){
System.out.println("SubClass: inside staticMethod");
}
......
public static void main(String []args){
......
SuperClass superClassWithSuperCons = new SuperClass();
SuperClass superClassWithSubCons = new SubClass();
SubClass subClassWithSubCons = new SubClass();
superClassWithSuperCons.staticMethod();
superClassWithSubCons.staticMethod();
subClassWithSubCons.staticMethod();
...
}
}
Output:-
SuperClass: inside staticMethod
SuperClass: inside staticMethod
SubClass: inside staticMethod
Notice the second line of the output. Had the staticMethod
been overriden this line should have been identical to the
third line as we're invoking the 'staticMethod()' on an
object of Runtime Type as 'SubClass' and not as
'SuperClass'. This confirms that the static methods are
always resolved using their compile time type information only.
| Is This Answer Correct ? | 3 Yes | 0 No |
Post New Answer View All Answers
How transient variable is different from volatile variable?
What about interrupt() method of thread class ?
1.IN CASE OF DYNAMIC METHOD DISPATCH WHY WE USE REFERENCE VARIABLE,WE CAN USE THE DIFFERENT DEFINED OBJECT DIRECTLY TO ACCESS THE DATA MEMBER AND MEMBER FUNCTION OF THAT RESPECTIVE CLASS?WHAT IS THE MAIN FUNCTION OF "REFERENCE VARIABLE" HERE?
can any body body expalin best definitions & best real time exaples for opps concepts.
Why scanner is used in java?
What isan abstract class and when do you use it?
Can we define a package statement after the import statement in java?
Is an array a vector?
Are arrays immutable in java?
Is there is any difference between a scrollbar and a scrollpane?
What is meant by local variable and instance variable?
How to display names of all components in a Container?
What is binary search in java?
What is the difference between path and classpath variables?
What is a hashmap used for?
