Static methods overriding?

public class SM{
static void doit(){System.out.println("SM static method");}
public static void main(String[] args) {
SM s = new SM();
s.doit();
public class SMsub extends SM{
static void doit(){System.out.println("SM static method this is a subclass");}
public static void main(String[] args) {
SMsub s = new SMsub();
s.doit();
}

I think what you have done is perfectly legal, however this is more like "overloading", rather than "overriding" which is the term used in case of polymorphism. Since these methods are static there is no question of polymorphism.

Similar Messages

On static method override-

just posted an example of over riding a static method . Is this legal? I mock cert exam is saying that static methods can not be overridden, What's the truth?

As I know static method cannot override by non-static method and vice versa.

Can we override Static methods?

Hi all, I m in little bit confusion abt static methods overriding.
Could you help me on this issue.,
Can we override Static methods?

You can provide static methods with same name in both super class and subclass. But it is not overriding in this scenario. Both will act as independent methods.
Example:
have a super class:
public class Test1 {
public static void mthdA()
System.out.println("in super");
have a sub class:
public class Test2 extends Test1{
public static void mthdA()
System.out.println("inside sub");
public static void main(String[] args){
Test1 objTest = new Test2();
objTest.mthdA();
Try to run the sub class Test2. The output would be "in super".
Remove static modifier in mthdA() in both the classes and then run. The output would be "in sub". Meaning, methdA is overriden in sub class.

Can you override a public static method?

Can you override a public static method?

A static method belongs to a class, not to a particular object, because you can call them without having an object instantiated. Methods are over rided which are inherited from an object. Since Static methods (although inherited) are not bound to a particular object, are not overridden.
Though you have a method in the subclass with the same signatures but if you try to call super.____() you will get the error
non-static variable super cannot be referenced from a static context

Overriding static method

hi all
can be override static method.if yes then how?plz explain.

Static methods do hide rather than override - the superclass-and-above methods are, however, visible via explicit referencing. Example:
public class Foo
     public static final void main(String[] args)
          Foo.foo();
          Poo.foo();
          Foo.bar();
          Poo.bar();
     public static void foo()
          System.out.println("Foo foo");
     public static void bar()
          System.out.println("Foo bar");
     public static class Poo extends Foo
          public static void foo()
               System.out.println("Poo foo");
          public static void bar()
               System.out.print("Poo bar, calling foo(): ");
               foo();
}Gives
Foo foo
Poo foo
Foo bar
Poo bar, calling foo(): Poo fooAlways more interesting to try stuff and just see what happens, don't you think? :o)
Message was edited by:
itchyscratchy - line wrap pasting error

Querry regarding overriding static methods

Hi ,
I m overriding a static method defined in superclass ThreadLocal1 as:
public static void mm()
     System.out.println("bye");
class Thread1 extends ThreadLocal1{
tt(){}
public static void mm()
     System.out.println("hi");
public static void main(String args[])
     Thread1 t1= new Thread1();
     ThreadLocal1 th1;
     th1=t1;          // t1 is assigned      th1.mm();
     t1.mm();
}output is : bye
hi
I am not getting why ref var th1 is not calling overridden method mm() when th1 is assigned t1 that is subclass instance.
when i m removing static modifier from mm(0 in superclass then output is : hi hi
plz clarify why is it so.....
Edited by: jawatch on Oct 29, 2007 7:01 AM

jawatch wrote:
@kajbj :
but i have overridden static method mm()No, you haven't. You've hidden it. Overriding only applies to non-private, non-final, non-static methods, and they are the only case where you can see the kind of polymorphism you're talking about.

About overriding static method inheritance

I have some class PO2VOPropertyUtilsBean which extends the org.apache.commons.beanutils.PropertyUtilsBean.
In PropertyUtilsBean,there is a method:
protected PropertyUtilsBean getInstance() {}I override it in my extend calss PO2VOPropertyUtilsBean:
protected PO2VOPropertyUtilsBean getInstance() {
return new PO2VOPropertyUtilsBean();
}I use Eclipse3.1+Myeclipse4.0,when i choose java5.0 as complier,that all be ok.
But when i copy the source to my company, my pc uses java1.4 as compiler,it show me errors in the getInstance() method:
imcompartible return type,it should return PropertyUtilsBean.
Why?

Ok, so the getInstance() methods are indeed static.
As Kaj said, static methods cannot be overridden.
You would call the method by the classname. For example:
PropertyUtilsBean bean = PropertyUtilsBean.getInstance();If you write a class PO2VOPropertyUtilsBean with a getInstance() method, the call above will still go to class PropertyUtilsBean, and not to your derived class. After all, how is Java supposed to know that you want to have the method in PO2VOPropertyUtilsBean called? You would need to change the call:
PropertyUtilsBean bean = PO2VOPropertyUtilsBean.getInstance();

How to call a static method in a class if I have just the object?

Hello. I have an abstract class A where I have a static method blah(). I have 2 classes that extend class A called B and C. In both classes I override method blah(). I have an array with objects of type B and C.
For every instance object of the array, I'm trying to call the static method in the corresponding class. For objects of type B I want to call blah() method in B class and for objects of type C I want to call blah() method in C class. I know it's possible to call a static method with the name of the object, too, but for some reason (?) it calls blah() method in class A if I try this.
So my question is: how do I code this? I guess I need to cast to the class name and then call the method with the class name, but I couldn't do it. I tried to use getClass() method to get the class name and it works, but I didn't know what to do from here...
So any help would be appreciated. Thank you.

As somebody already said, to get the behavior you
want, make the methods non-static.You all asked me why I need that method to be
static... I'm not surprised to hear this question
because I asked all my friends before posting here,
and all of them asked me this... It's because some
complicated reasons, I doubt it.
the application I'm writing is
quite big...Irrelevant.
Umm... So what you're saying is there is no way to do
this with that method being static? The behavior you describe cannot be obtained with only static methods in Java. You'd have to explicitly determine the class and then explicitly call the correct class' method.

Redefine static method?

It seems that I cannot redefine a static method in a subclass in ABAP OO, right?
Is there a reason for that? Is this like this in other languages as well?

That's true. You cannot redefine static methods in ABAP OO.
I can add that a class that defines a public or protected static attribute shares this
attribute with all its subclasses.
Overriding static methods is possible for example in Java.
This simple piece of code illustrates this:
public class Super {
    public static String getNum(){
        return "I'm super";
     public static void main(String[] args) {
         System.out.println("Super: " + Super.getNum());
         System.out.println("Sub: " + Sub.getNum());
public class Sub extends Super{
    public static String getNum(){
        return "I'm not";
The output is:
Super: I'm super
Sub: I'm not
When overriding methods in Java you must remember that an instance method cannot override a static method, and a static method cannot hide an instance method.
In C# a static member can't be marked as 'override', 'virtual' or 'abstract'. But it it is possible to hide a base class static method in a sub-class by using the keyword 'new':
public class Super
public static void myMethod()
public class Sub: Super
public new static void myMethod()

How to get the current class name in static method?

Hi,
I'd like to get the current class name in a static method. This class is intended to be extended. So I would expect that the subclass need not to override this method and at the runtime, the method can get the subclass name.
getClass() doesn't work, because it is not a static method.
I would suggest Java to make getClass() static. It makes sense.
But in the mean time, does anybody give an idea to work around it?
Thank you,
Bill

Why not create an instance in a static method and use getClass() of the instance?
public class Test {
public static Class getClassName() {
return new Test().getClass();

Abstract static methods

Hello,
I've written an abstract class, called AbstractNetworkParticipant. I've also written two sub classes that extend this class. I'm in the process of writing a Viewer class that I'm intending to parameterized with some subclass of AbstractNetworkParticipant,
public class Viewer<T extends AbstractNetworkParticipant> I would like to include a couple of static methods that return Strings for Labeling information to a particular subclass in the Viewer.
So for example, if I have NetworkUser and NetworkAdministrator, both of which extend AbstractNetworkParticipant, I would like to set the text of a JLabel labeling the participant's name to "User Name", or "Administrator Name" depending on the type of participant being viewed.
I would like the method that returns these strings to be static, so that I don't have to have an instance of the current subclass when I initializes the JLabel. An abstract method cannot be static. I attempted to make a non-abstract static method in the abstract class,
public static getDescriptor() {
     return "Participant";
}and then override it in each sub class to a more descriptive string (User, or Administrator). However, when I reference the method, it always invokes the method defined in the abstract parent class, rather than in the subclass, whichever it may be.
Can anyone suggest a solution. Should I just forget about the method being static? Is there a better way to implement a solution to this problem?
Thanks
Edited by: paulwooten on Mar 27, 2009 9:58 AM

paulwooten wrote:
The whole point of my original post was in order to learn something about Java that I'm not particularly familiar with. I was having a difficult time articulating the problem precisely, so I tried to draw an analogy between C++ and Java. It turns out I was mistaken in the way C++ works. Fortunately I described my problem adequately enough to both 1. be corrected about how virtual functions actually work in C++, and 2. get advice on how to approach the problem in Java. I never claimed I was a C++ expert, or that I was asking a question about C++. I was just trying to explain my problem as precisely as possible.
I don't mean to disrespect, but your post, and slimy's aren't nearly as constructive as all the other posts that actually addressed my question; either to me personally, or to anyone else who has a similar question and may happen to read this thread. It's not like I dumped a bunch of C++ code here and begged someone to translate it for me. I asked a question, to the best of my ability, several other forum members replied (without giving me a mini lecture on how to learn Java), and now the problem is resolved.Sorry for the confusion. I wasn't complaining about your post. My post wasn't directed at you at all. It's fine to know C++, and to ask how to do something similar in Java. As you said, that wasn't even how you asked your original question. You asked a legitimate question to learn Java, a few people made suggestions, you made a comparison to C++, and people corrected your understanding both of C++ and Java. That's all well and good, and it's a fair way to learn. I see no problem with any of that.
What exactly does "learn Java properly" mean? Read the tutorials and pretend like no other programming languages exist?I was referring to slimy's post where he talked about "knowing C++ properly if you use it as an input to Java". The point of my post was supposed to be that "you can know C++ properly, but +you shouldn't always use that as your input to Java+". A very simple example I've seen of what I meant by "non-proper" Java code, in real [but +bad+ ] Java code at a real company is for String comparison:
String abc = "abc";
String xyz = "xyz";
String another = "xyz";
if (abc.compareTo(xyz) != 0) { // Not "proper" Java
   doSomething();
if (xyz.compareTo(another) == 0) { // Not "proper" Java
   doSomethingElse()
}To me, that looks like someone who copied their C++ knowledge (or, at least, C knowledge) to the extreme. In C, the only function to test equality of two C "strings"--i.e., "null-terminated char arrays" is 'strcmp', and you test equality of the strcmp result to 0 to determine whether two "null-terminated char arrays" represent the same thing:
char abc [] = "abc";
char xyz [] = "xyz";
char another [] = "xyz";
if (strcmp(abc, xyz)) { // could include explicit != 0, but not needed in C
   doSomething();
if (!strcmp(xyz, another)) { // anything non-zero is true in C, so !0 is true
   doSomethingElse();
}"compareTo" sounds like "strcmp", and the comparison to 0 is the same in my above examples.
But, in Java, there is a real "equals" method for Strings, and it should be used:
String abc = "abc";
String xyz = "xyz";
String another = "xyz";
if (!abc.equals(xyz)) { // "proper" Java
   doSomething();
if (xyz.equals(another)) { // "proper" Java
   doSomethingElse()
}I would argue that using "compareTo" to test equality of Strings in Java is "non-proper" Java, and using "equals" to test equality of Strings in Java is "proper" Java. That was my definition of "learning Java properly".
I certainly don't think anyone learning Java needs to pretend that no other programming languages exist--it is fine to know other languages, and to look for the similarities (and differences). However, someone learning Java (or any other language new to them) does need to know that things don't work the same in all languages, so, if they base all of their knowledge by trying to get Java to work exactly the same as C++ (or whatever previous language they knew), their Java will not be "proper" Java. There are often multiple ways to do things "properly" in Java, but copying a C++ program verbatim into Java syntax is not necessarily going to result in the best Java code that you could have. When doing the translation from another language to Java (I realize that isn't your goal, but for some people, that is the goal), you need to be sure that your Java code follows Java rules and standards, and not just assume that the architecture of your Java code should be the same as the architecture of your code in the original language.
I hope that clarifies my intentions. As I said, I wasn't directing my previous comment to you. I think your question and learning approach are absolutely fine.

JUnit : How to Mock Static Method

Hi,
I was using EasyMock to write Junit for the methods of the class.
The Limitation of this library is that only Interfaces can be mocked without any much effort and behavior can be set according to our needs.
Since, now we need to mock even normal classes, I got mocuer library from net and this too is easy to implement. The problem / limitation is that, I cant mock static methods of a class.
Is there is any workaround / library so that even static methods can be mocked??.
Advance thanks.

Since you would like to mock the static method, it is not part of the class you'd like to test, I assume. The class you do want to test is supposedly under your control and contains the static invocation. I'd suggest to refactor the use of the static invocation in the class being tested.
I see two approaches:
1. wrap the static method call in an instance of newly created service class.
   public class ServiceMethodWrapperImpl implements ServiceMethodWrapper {
       public int serviceCall(String arg) {
         return OtherClass.staticMethod(arg);
   }and then mock the ServiceMethoWrapper interface for testing
2. wrap the static call in a protected method of the class under test. In you test case, test a derived class in which you override the method that calls the service to use a mock:
   public class TestedClass {
     protected int callStaticMethod(String arg) {
         return OtherClass.staticMethod(arg);
     public void something() {
         // replaced OtherClass.staticMethod by
         if (callStaticMethod("Sun") == 3) {
   public void testSomethingForTheClass() {
      TestedClass instance = new TestedClass() {
           protected int callStaticMethod(String arg) {
                return 3; // mocked answer
   }

Static methods in interfaces

Java cognoscenti,
Anyone know why I can't declare a method as static in an interface, but I can in an abstract class. Surely, semantically it's the same - defering the implementation of a static method, not an abstract class and an interface. By the way, I'm using JDK 1.2.2 if that makes a difference

No, it's not the same. You are not "defering the
implementation of a static method" because static
methods are never polymorphic.
Static methods cannot be abstract for this reason, and
only abstract methods are allowed in interfaces.I didnt't know that. I thought that - because you can override static methods and you can call them onto an actual instance the method binding would be done at run-time, not at compile-time. So I was trying to prove you wrong, but you are correct !
A short summary of what I've learnt so far:
- interfaces cannot contain static methods
- abstract classes cannot contain abstract static methods
- static methods can be overriden, but they are not polymorphic; this means that the compiler decides which method to call at compile-time.
/* output
SuperClass.someMethod()
SubClass.someMethod()
SuperClass.someMethod()
SuperClass.someMethod()
SubClass.someMethod()
SubClass.someMethod()
SuperClass.someMethod()
public class Test {
public final static void main(String[] args) {
      // output: SuperClass.someMethod()
      new SuperClass().someMethod();
      // output: SubClass.someMethod()
      new SubClass().someMethod();
      // output: 2x SuperClass.someMethod()
      SuperClass someClass1 = new SubClass();
      someClass1.someMethod();
      showSuper(someClass1);
      // output: 2x SubClass.someMethod()
      SubClass someClass2 = new SubClass();
      someClass2.someMethod();
      showSub(someClass2);
      showSuper(someClass2); // SuperClass.someMethod()
public final static void showSuper(SuperClass c) {
        c.someMethod();
public final static void showSub(SubClass c) {
        c.someMethod();
class SuperClass {
public static void someMethod() {
    System.out.println("SuperClass.someMethod()");
class SubClass extends SuperClass {
public static void someMethod() {
    System.out.println("SubClass.someMethod()");

What's the role of 'throws' clause in method overriding

I'm getting error when subclass "Parser" overrides method 'getInt()' which throws Exception but super class version don't. It is compiling without error when vice versa is true i.e., super class version throws exception but sub class version don't throw exception.
What's the role of 'Throws' clause in method overriding?
What's the rationale with the output of following program?
class Parser extends Utils {
   public static void main(String [] args) {
     System.out.print(new Parser().getInt("45"));
int getInt(String arg) throws Exception{
     return Integer.parseInt(arg);
class Utils {
   int getInt(String arg) { return 42; }
}

karthikbhuvana wrote:
I'm getting error when subclass "Parser" overrides method 'getInt()' which throws Exception but super class version don't. It is compiling without error when vice versa is true i.e., super class version throws exception but sub class version don't throw exception.
What's the role of 'Throws' clause in method overriding?
What's the rationale with the output of following program?
class Parser extends Utils {
public static void main(String [] args) {
System.out.print(new Parser().getInt("45"));
int getInt(String arg) throws Exception{
return Integer.parseInt(arg);
class Utils {
int getInt(String arg) { return 42; }
Supose you do:
Utils u = new Parser();
int i = u.getInt("XX");This would throw a NumberFormatException, which is a checked exception, yet the compiler doesn't know this because Util.getInt() has no throws clause. Such a loophole would defeat the whole point of having throws clauses.
So a method can only implement or override another if the throws clause on the interface or superclass admits the possibility of throwing every exception that the implementing method can throw, thus code which calls the method from a superclass or interface reference doesn't get any unexpected exceptions.

Static Methods, the case of HashMap

    static int hash(Object x) {
        int h = x.hashCode();
        h += ~(h << 9);
        h ^= (h >>> 14);
        h += (h << 4);
        h ^= (h >>> 10);
        return h;I was cruising the HashMap class. And I noticed right away that all non interface methods were static package methods. Now isn't that bad OOP practice? Right. It breaks the inheritance relationship.
It means I cannot make a subclass of HashMap and re-write that hash function. Was that intentional?
on a OOP perspective or
on a down to earth matter,
Are static method more performant in speed? Or memory ( i guess yes here)? or what?

I was cruising the HashMap class. And I noticed right
away that all non interface methods were static
package methods. Now isn't that bad OOP practice?
Right. It breaks the inheritance relationship.
It means I cannot make a subclass of HashMap and
re-write that hash function. Was that intentional?If they are package-private, I take it for granted they didn't want application developers to redefine these methods.
If they are static, they are also preventing themselves (Javasoft) to override them in subclasses that would be included in the JDK.
I'd say in both cases, that it is intentional, since, at least in the case of the hash function, the intent is to disperse hash results even for low-dispersing custom hash functions, as was explained in another thread in ALT (wasn't it you already? ;-).
This is maybe questionable, but defendable, that they didn't want any subclass to mess with these "optimizations".
You can regard this as poor OO practice, but this is no more hampering you that if they had declared the method as private.
I acknowledge that declaring the method private has the advantage of making explicit that they don't want anyone to override it.
But by declaring it static package, they ensure no-one can override it, so the other methods in HashMap relying on this method are guaranteed that no subclass can mess with it, but other classes in the same package (say, WeakHashMap, HashSet,...), can call it. all the same
Are static method more performant in speed? Or memory
( i guess yes here)? or what?Static methods are not faster in themselves, but invoking them may be, since they can be "statically" resolved.
When the calling class is loaded in memory, the callee is loaded too, and the interpreter or JIT or HotSpot is free to inline the static method's body (no indirection).
Even if it doesn't, invoking the static method implies to moving the program counter or pointer, or whatever, to an adress that has already been resolved once and for all (one indirection),
whereas invoking a virtual method implies a double indirection, looking up the address in some kind of dynamic table (one per class, determined by the target object's leaf class).
There are indeed two different bytecodes for these two situations!

Static methods overriding?

Similar Messages

Maybe you are looking for