Can i override a static method if not why

You can overload static method, that's ok. But you can not override a static method, because class are no first-class object. You can use reflection to get the class of an object at run-time, but the object that you get does not parallel the class hierarchy.

You can reflect over the classes, but it stops there. You don't invoke a static method by using clazz1. A static method is not bound to an object and there is hence no notion of this nor super in a static method.

A static method is a global function; as a consequence there is also no notion of polymorphism and, therefore, method overriding makes no sense. But this could be possible if MyClass was an object at run-time on which you invoke a method, as in Smalltalk or maybe JRuby as one comment suggest, but I know nothing of JRuby. Oh yeah You can invoke a static method through an object obj1. It usually raises a warning in modern IDE.

I don't know why they ever allowed this shortcut. Method overriding is made possible by dynamic dispatching , meaning that the declared type of an object doesn't determine its behavior, but rather its runtime type:. Even though both lassie and kermit are declared as objects of type Animal , their behavior method. Now, here's where the static keyword starts to make sense: the word "static" is an antonym for "dynamic". So the reason why you can't override static methods is because there is no dynamic dispatching on static members - because static literally means "not dynamic".

If they dispatched dynamically and thus could be overriden the static keyword just wouldn't make sense anymore. Practically Java allows overriding static method, and No theoretically if you Override a static method in Java then it will compile and run smoothly but it will lose Polymorphism which is the basic property of Java.

You will Read Everywhere that it is not possible to try yourself compiling and running. If you Have Class Animal and a static method eat and you Override that static method in its Subclass lets called it Dog. But the result was different because to support Polymorphism Java uses Late Binding that means methods are called only at the run-time but not in the case of static methods. In static methods compiler calls methods at the compile time rather than the run-time, so we get methods according to the reference and not according to the object a reference a containing that's why You can say Practically it supports static overring but theoretically, it doesn't.

In Java and many OOP languages, but I cannot speak for all; and some do not have static at all all methods have a fixed signature - the parameters and types. In a virtual method, the first parameter is implied: a reference to the object itself and when called from within the object, the compiler automatically adds this. There is no difference for static methods - they still have a fixed signature.

However, by declaring the method static you have explicitly stated that the compiler must not include the implied object parameter at the beginning of that signature. Therefore, any other code that calls this must must not attempt to put a reference to an object on the stack. If it did do that, then the method execution would not work since the parameters would be in the wrong place - shifted by one - on the stack. Because of this difference between the two; virtual methods always have a reference to the context object i.

But with static methods, since there is no reference passed, that method cannot access any object variables and methods since the context is not known. If you wish that Java would change the definition so that a object context is passed in for every method, static or virtual, then you would in essence have only virtual methods. As someone asked in a comment to the op - what is your reason and purpose for wanting this feature? I do not know Ruby much, as this was mentioned by the OP, I did some research.

I see that in Ruby classes are really a special kind of object and one can create even dynamically new methods. Classes are full class objects in Ruby, they are not in Java.

This is just something you will have to accept when working with Java or C. These are not dynamic languages, though C is adding some forms of dynamic. In reality, Ruby does not have "static" methods as far as I could find - in that case these are methods on the singleton class object.

You can then override this singleton with a new class and the methods in the previous class object will call those defined in the new class correct? So if you called a method in the context of the original class it still would only execute the original statics, but calling a method in the derived class, would call methods either from the parent or sub-class.

Interesting and I can see some value in that. It takes a different thought pattern. Since you are working in Java, you will need to adjust to that way of doing things.

Why they did this? Well, probably to improve performance at the time based on the technology and understanding that was available. Computer languages are constantly evolving. Go back far enough and there is no such thing as OOP. In the future, there will be other new ideas. EDIT : One other comment. Java static methods are not the same as Ruby class methods. I can see how this would also be greatly confusing by the fact that Java also uses "class method" as another way to talk about static methods but this same term is used differently by Ruby.

Java does not have Ruby style class methods sorry ; Ruby does not have Java style static methods which are really just old procedural style functions, as found in C. By the way - thanks for the question! I learned something new for me today about class methods Ruby style. 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. 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 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. In general it doesn't make sense to allow 'overriding' of static methods as there would be no good way to determine which one to call at runtime.

Taking the Employee example, if we call RegularEmployee. In the case of Java, one could imagine a language definition where it is possible to 'override' static methods as long as they are called through an object instance. However, all this would do is to re-implement regular class methods, adding redundancy to the language without really adding any benefit.

By overriding we can create a polymorphic nature depending on the object type. Static method has no relation with object. So java can not support static method overriding. I agree that this is the bad design of Java. Many other languages support overriding static methods, as we see in previous comments. I feel Jay has also come to Java from Delphi like me. Delphi Object Pascal was one of the languages implementing OOP before Java and one of the first languages used for commercial application development.

It is obvious that many people had experience with that language since it was in the past the only language to write commercial GUI products. And - yes, we could in Delphi override static methods. Actually, static methods in Delphi are called "class methods", while Delphi had the different concept of "Delphi static methods" which were methods with early binding. To override methods you had to use late binding, declare "virtual" directive.

So it was very convenient and intuitive and I would expect this in Java. By overriding, you achieve dynamic polymorphism. When you say overriding static methods, the words you are trying to use are contradictory. Static says - compile time, overriding is used for dynamic polymorphism. Both are opposite in nature, and hence can't be used together.

Dynamic polymorphic behavior comes when a programmer uses an object and accessing an instance method. JRE will map different instance methods of different classes based on what kind of object you are using. When you say overriding static methods, static methods we will access by using the class name, which will be linked at compile time, so there is no concept of linking methods at runtime with static methods.

Python Design Patterns. Python Pillow. Python Turtle. Verbal Ability. Interview Questions. Company Questions. Artificial Intelligence. Cloud Computing. Data Science. Angular 7. Machine Learning. Data Structures. Operating System. Computer Network. Compiler Design. Computer Organization. Discrete Mathematics. Ethical Hacking. Computer Graphics. Software Engineering. This explanation also clear this line- "Polymorphic method invocations apply only to overridden instance methods.

Since main method is static in Java, it looks we can not override main in Java but what will happen if I use varargs version of main method in Super class and String[] version of main method in SubClass, which main method will be invoked? For your question "if I use varargs version of main method in Super class and String[] version of main method in SubClass, which main method will be invoked?

This program will not compile bcoz You can use static keyword only with ineer classes. Absolutely right! Outer class can never be static in Java. AnonymousDecember 15, at AM : Try the example that Javin explained but this time make the static methods as non static in both Screen and ColourScreen classes i. We are able to override static and private methods.

Hi Unknown, can you please detail me what exactly did your do for overriding static method? Actually I wanted to override main is that possible in later versions of Java. Feel free to comment, ask questions if you have any doubt. Pages Home core java spring online courses thread java 8 coding sql books oop interview certification free resources best. Note that signatures of both methods must be the same. Refer Overriding in Java for details. Overloading : Overloading is also a feature of OOP languages like Java that is related to compile-time or static polymorphism.

This feature allows different methods to have the same name, but different signatures, especially the number of input parameters and type of input parameters. Can we overload static methods? We can have two or more static methods with the same name, but differences in input parameters.

For example, consider the following Java program. Attention reader! Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. We cannot overload two methods in Java if they differ only by static keyword number of parameters and types of parameters is the same.