Make private methods final?

Question

Is it beneficial to make private methods final? Would that improve performance?

I think "private final" doesn't make much sense, because a private method cannot be overridden. So the method lookup should be efficient as when using final.

And would it be better to make a private helper method static (when possible)?

What's best to use?

  private Result doSomething()
  private final Result doSomething()
  private static Result doSomething()
  private static final Result doSomething()

Solution 1

Adding final to methods does not improve performance with Sun HotSpot. Where final could be added, HotSpot will notice that the method is never overridden and so treat it the same.

In Java private methods are non-virtual. You can't override them, even using nested classes where they may be accessible to subclasses. For instance methods the instructoin to call privates is different from that used for non-privates. Adding final to private methods makes no odds.

As ever, these sort of micro-optimisations are not worth spending time on.

Solution 2

private static Result doSomething(), if this method is not using any instance variables. In any case making them final makes no sense since the accessor is private.

Solution 3

No. It will not. private methods are not inherited. So making them final is a moot point. Also note that you should not make methods final for performance. JVM is smarter than that. This kind of optimization is not much useful. You should make things final, private, private, protected, private, etc based on the semantics and design.

Solution 4

Marking a private method as final does not change anything but it might confuse junior developers looking at your code. Keep it simple.

Solution 5

The IBM Developer works: Java theory and practice: Is that your final answer? article is an oldie but goodie about using the final keyword in Java:

View more solutions

Comments

[Matt Greer]

Man I wish C# had a final keyword. Instead it's got const, readonly and sealed. bleh.

[Alberto Zaccagni]

It will not hit the performance, compilers are smarter than this

[Maarten Bodewes]

... in 99.9% of the time. And you'll know when micro-optimizations do make sense. More importantly, private final method declarations make no sense semantically so it only adds confusion where there was none; just private should suffice.

[Yousha Aleayoub]

How about Inner Classes ?