Java can you override a static method

The point of polymorphism is that you can subclass a class and the objects implementing those subclasses will have different behaviors for the same methods defined in the superclass and overridden in the subclasses. A static method is not associated with any instance of a class so the concept is not applicable.

There were two considerations driving Java's design that impacted this. One was a concern with performance: there had been a lot of criticism of Smalltalk about it being too slow garbage collection and polymorphic calls being part of that and Java's creators were determined to avoid that. Personally I think this is a flaw in the design of Java.

Yes, yes, I understand that non-static methods are attached to an instance while static methods are attached to a class, etc etc. Still, consider the following code:. This code will not work as you might expect.

Admittedly, this example is poor coding style in that in real life you would likely want the bonus multiplier to be in a database somewhere rather than hard-coded. But that's just because I didn't want to bog down the example with a lot of code irrelevant to the point. It seems quite plausible to me that you might want to make getBonusMultiplier static. Perhaps you want to be able to display the bonus multiplier for all the categories of employees, without needing to have an instance of an employee in each category.

What would be the point of searching for such example instances? What if we are creating a new category of employee and don't have any employees assigned to it yet? This is quite logically a static function. And yes, yes, I can think of any number of ways to rewrite the above code to make it work. My point is not that it creates an unsolvable problem, but that it creates a trap for the unwary programmer, because the language does not behave as I think a reasonable person would expect.

Perhaps if I tried to write a compiler for an OOP language, I would quickly see why implementing it so that static functions can be overriden would be difficult or impossible. Or perhaps there is some good reason why Java behaves this way. Can anyone point out an advantage to this behavior, some category of problem that is made easier by this? I mean, don't just point me to the Java language spec and say "see, this is documented how it behaves".

I know that. Besides the obvious "making it work right was too hard" VicKirk: If you mean that this is "bad design" because it doesn't fit how Java handles statics, my reply is, "Well, duh, of course. But if you mean that it is bad design in the sense that there would be something fundamentally wrong with a language where this worked, i. What's wrong with the concept?

I think the example I give is a very natural thing to want to do. I have a class that has a function that does not depend on any instance data, and which I might very reasonably want to call independent of an instance, as well as wanting to call from within an instance method.

Why should this not work? I've run into this situation a fair number of times over the years. In practice I get around it by making the function virtual, and then creating a static method whose only purpose in life is to be a static method that passes the call on to the virtual method with a dummy instance. That seems like a very roundabout way to get there.

Here is some code which illustrates the current state of affairs in Java:. Here, the only cases which might be a surprise and which the question is about appear to be the first case:. The static call is resolved at compile-time, whereas a non-static method call is resolved at run-time. Notice that although static methods are inherited from parent they are not overridden by child. This could be a surprise if you expected otherwise. Object method calls are resolved using the run-time type, but static class method calls are resolved using the compile-time declared type.

To change these rules, so that the last call in the example called Child. Static calls could then use the dynamic type hierarchy to resolve the call, just as object method calls do today. This would easily be doable if we changed Java :-O , and is not at all unreasonable, however, it has some interesting considerations. The main consideration is that we need to decide which static method calls should do this.

At the moment, Java has this "quirk" in the language whereby obj. If we did it would make method bodies harder to read: static calls in a parent class could potentially be dynamically "re-routed". To avoid this we would have to call the static method with a class name -- and this makes the calls more obviously resolved with the compile-time type hierarchy as now.

The other ways of invoking a static method are more tricky: this. However, this might cause some headaches with existing programs, which call apparently local static methods without decoration which is arguably equivalent to this. So what about unadorned calls staticMethod?

I suggest they do the same as today, and use the local class context to decide what to do. Otherwise great confusion would ensue. Of course it means that method would mean this. This is another source of confusion. If we changed this behaviour and made static calls potentially dynamically non-local , we would probably want to revisit the meaning of final , private and protected as qualifiers on static methods of a class.

We would then all have to get used to the fact that private static and public final methods are not overridden, and can therefore be safely resolved at compile-time, and are "safe" to read as local references. Actually we were wrong. Despite Java doesn't allow you to override static methods by default, if you look thoroughly through documentation of Class and Method classes in Java, you can still find a way to emulate static methods overriding by following workaround:.

Even if we declare third variable Carl as RegularEmployee and assign to it instance of SpecialEmployee, we will still have call of RegularEmployee method in first case and call of SpecialEmployee method in second case. Static methods are treated as global by the JVM, there are not bound to an object instance at all.

It could conceptually be possible if you could call static methods from class objects like in languages like Smalltalk but it's not the case in Java.

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.

It's completely free and you just need a free Udemy account to join this course. Labels: core java , interview questions , object oriented programming. Unknown August 28, at AM. Ahmad August 28, at PM. Anonymous September 12, at PM. Mee Shreyobhilashi January 29, at AM. Anonymous October 24, at AM. Anonymous December 15, at AM. Anonymous January 29, at AM. Rahul Askar February 4, at AM. Anonymous August 26, at AM. Unknown September 18, at PM. There were two considerations driving Java's design that impacted this.

One was a concern with performance: there had been a lot of criticism of Smalltalk about it being too slow garbage collection and polymorphic calls being part of that and Java's creators were determined to avoid that. Java doesn't allow overriding of static methods.. To see this, change the main method to the following.. In Java 1. It's a free check by the compiler. By the way, with static methods, you can not use Override annotation, it's compilation error. Anonymous, Thanks for kind words, and I am glad that you find this Java Blog useful.

Method Overriding VS Method Hiding in java If and instance method in a subclass has same signature and return type as instance method in the superclass ,it is called overriding. Method signature means name, and the number and the type of its parameters.

Number ,type of the parameters should be same in method written in super class and sub class. This is called a co-variant return type. If a class method in subclass has the same signature as a class method in the superclass, This is called method hiding.

I tried to override static variable in Java 7. I am able to do it. AlienOnEarth, it's not overriding but hiding, static variables are resolved at compile time by using Type of variable, Sine you are accessing them in TestParent class, it's print "test". Though it is certainly possible, does it not defeat the whole purpose of static modifier. Please correct me if I am wrong, however I felt compelled to post my query. Regards, Ravi Prakash. Post a Comment. Can a static method be overridden in Java, or can you override and overload static method in Java , is a common Java interview questions mostly asked to 2 years experienced Java programmers.

The answer is, No, you can not override static method in Java , though you can declare a method with the same signature in a subclass. It won't be overridden in the exact sense, instead, that is called method hiding. But at the same time, you can overload static methods in Java, there is nothing wrong with declaring static methods with the same name, but different arguments.

Some time interviewer also ask, Why you can not override static methods in Java? The answer is No. We cannot override two methods if they differ only by static keyword. No, we cannot override static methods because method overriding is based on dynamic binding at runtime and the static methods are bonded using static binding at compile time.

So, we cannot override static methods. In the following example, the ParentClass has a static method named display and the ChildClass also has the same method signature. The method in the derived class ChildClass hides the method in the base class. JavaTpoint offers too many high quality services. Mail us on [email protected] , to get more information about given services. Please mail your requirement at [email protected] Duration: 1 week to 2 week. Java Training Java Tutorial. Abstract class Interface Abstract vs Interface.

Package Access Modifiers Encapsulation. Next Topic Java Tutorial. Reinforcement Learning. R Programming. React Native. Python Design Patterns. Python Pillow. Python Turtle. Verbal Ability.