CODEWITHSUNDEEP
javaperformancestatic
wondergoat77
wondergoat77

Reputation: 1815

Does accessing methods in a non static way affect/benefit performance?

Assuming all method calls here are static, like this:

public class Util {
    public static void method1() {
    }
}

Accessing in a static way:

Util.method1();
Util.method2();
Util.method3();

accessing in a non static way

Util util = new Util();
util.method1();
util.method2();
util.method3();

Is there any performance difference for either way? I know the first way of doing it here is accessing it properly. But the second way only instantiates the util object once as opposed to three times. I can't find anything pointing to anything other than to be accessing these methods properly. From what I can tell there is no functional difference, but a logical difference. Looking for sort of a cost vs. benefit of either way if anyone knows.

Upvotes: 3

Views: 162

Answers (2)

Jon Skeet
Jon Skeet

Reputation: 1499760

Is there any performance difference for either way?

Yes - the second is marginally slower, due to a pointless instance being constructed.

I know the first way of doing it here is accessing it properly. But the second way only instantiates the util object once as opposed to three times.

No, the second way creates one instance of Util whereas the first way doesn't create any instances.

The first way is significantly better, because it makes it clear that it is a static method. Consider this code:

Thread t = new Thread(someRunnable);
t.start();
t.sleep(1000);

What does it look like that last call does? Surely it makes the new thread sleep, right? No... it just calls Thread.sleep(), which only ever makes the current thread sleep.

When you mangle a static method call to act "through" a reference, the value of the reference is completely ignored - it can even be null:

Util util = null;
util.method1(); // This will still work...

Upvotes: 12

markspace
markspace

Reputation: 11020

There's no difference for the code you show, since all those methods are static. (The compiler will issue a warning for the second group, however.) I think there's a small performance benefit to static methods. The underlying byte code for static access, invokeSpecial I think, should be faster than invokeVirtual, which has to do some type decoding.

But it's not enough to worry about. Use whichever type of method (static vs. instance) is right for your design. Don't try to optimize the method calls like that.

Upvotes: 0

Related Questions