Calling a static method given an instance

Question

In this answer there is this code:

//in a main method somewhere
Super instance = new Sub();
instance.method();

//...
public class Super {
    public static void method() {
        System.out.println("Super");
    }
}

public class Sub extends Super {
    public static void method() {
        System.out.println("Sub");
    }
}

This prints Super as expected, but I have some code where given an instance, I would like to call the static Sub.method(). One solution could be:

public class Sub extends Super {
    public static void sMethod() {
        Super.sMethod();
        System.out.println("Sub (static)");
    }
    public void method() {
        super.method();
        System.out.println("Sub (instance)");
    }
}

However, with non-trivial function bodies (in my case I am checking a parameter falls within limits allowed for the class) there is a lot of repeated code. Is there a good design pattern to resolve this? Reflection would work, perhaps, but it feels like a last resort.

Thinking a bit more, is this any better?

public class Sub extends Super {
    public static void sMethod() {
        Super.sMethod();
        System.out.println("Sub (static)");
    }
    public void method() {
        Sub.sMethod();
    }
}

the question is why you need static? static methods are class level, has no sense cause you are not overriding — nachokk, Jul 05 '13 at 00:40
I'm about 98% sure that there's no way to do it other than reflections. There is simply nothing in the bytecode "vocabulary" to specify this. — Hot Licks, Jul 05 '13 at 00:41
Why must the method be static when you call it from an instance? — mmirwaldt, Jul 05 '13 at 00:44
i added anti pattern tag cause i think this is not a good object design practice — nachokk, Jul 05 '13 at 01:01
@DGomez: Indeed! It is some legacy code I have inherited, which created a temporary instance of the subclass on the fly to perform checking that could be done in a static method, so I was wondering if I could remove the temporary object creation. — Ken Y-N, Jul 05 '13 at 01:02

nachokk · Accepted Answer · 2013-07-05T01:12:17.697

0

if you want to call class level method, you don't need an object, just put

Subclass.method();

For reading your comments i think you need basic object inheritance and take approach of polymorphism.

public class Super {
    public  void method() {
        System.out.println("Super");
    }
}

public class Sub extends Super {
    public  void method() {
        System.out.println("Sub");
    }
}
//in a main method somewhere
Super instance = new Sub();
instance.method();

Now you know what method will execute in runtime time, this is call polymorphism and is a main feature from OOP.

And if you still need and static method for some reason in method declaration then you call for example

public class SubClass extends SuperClass{

public static void method2(){
  //do Something
}

@Override
public void method(){
  Subclass.method2();
}

}

edited Jul 05 '13 at 01:12

answered Jul 05 '13 at 00:42

nachokk

14,363
4
24
53

That's my whole problem, in a complex hierarchy I don't know which `Subclass` to call! – Ken Y-N Jul 05 '13 at 00:59
@KenY-N you are confusing objects with class level methods.. you don't need an instance of something... the better solution is not to use static.. you don't inherit static methods... i suggest delete static and then take approach of polymorphism – nachokk Jul 05 '13 at 01:01

score 0 · Answer 2 · answered Jul 09 '13 at 19:50

Static methods are not OO. They're a handy way to store data about a class in simple cases and we all use them a lot, but as things get complicated they become awkward and even impossible.

You might find it easiest to stick with the original solution. (At least it avoids static methods.) But you did ask about a "good design pattern", so:

What you want are two instances of two classes, say MetaSub and MetaSuper, that have methods and data refering to Sub or Super. They need to implement the same interface (call it Meta), so you can get the data without worrying about which you actually have. All instances of Super would have a method getMeta which returns a Meta instance, either MetaSub or MetaSuper as the original is a Sub or not.

Now it's real easy. Call getMeta on your Super object, then call the method method on whatever that returns, and you're done. You've called the right method.

The Meta classes/interfaces replace the static class-level methods (and data) with real OO-style instance methods. You can inherit, extend, and override freely.

You can expand this as needed, with a Meta instance for every Super subclass--and even classes that don't extend Super. And you can have Meta2, Meta3, ... interfaces which might extend others or not. You can even have two objects of the same class with different Meta objects if you want. Also, the Meta instances can be used to label the contentents of collections--"This collections contains Sub objects." It's a lot more powerful than using a Class identifier.

(All it takes is time. Admittedly this is a lot more fun if you're writing something new rather than extending a legacy system.)

Calling a static method given an instance

2 Answers2