java - is initializing a temporary variable for simple getters better or not?

Question

A very unimportant question about Java performance, but it made me wondering today.

Say I have simple getter:

public Object getSomething() {
     return this.member;
}

Now, say I need the result of getSomething() twice (or more) in some function/algorithm. My question: is there any difference in either calling getSomething() twice (or more) or in declaring a temporary, local variable and use this variable from then on?

That is, either

public void algo() {
    Object o = getSomething();

    ... use o ...
}

or

public void algo() {
    ... call getSomething() multiple times ...
}

I tend to mix both options, for no specific reason. I know it doesn't matter, but I am just wondering.

Thanks!

Yes there is a difference, in the case the value changes in the meantime, perhaps via another thread, or if the getter was coded to have side effects! — Adam
– Adam, Commented May 15, 2012 at 20:50
Let's assume this won't happen here. My question is not about the difference in behavior, which is a valid remark, but about the difference of the output of the compiler. — John T.
– John T., Commented May 15, 2012 at 20:51
Have you tried to measure it? Does it impact on the overall performance of your program? JVM is pretty smart on optimizations of such kind, so it's impossible to tell. — Boris Treukhov
– Boris Treukhov, Commented May 15, 2012 at 20:51
I'm not sure this can be optimized as behaviour could be different... — Adam
– Adam, Commented May 15, 2012 at 20:52
@Adam JVM works with dynamic code - it can introduce optimizations and revert them back if the wind changes, for example when a new class being loaded that overrides getSomething, etc. — Boris Treukhov
– Boris Treukhov, Commented May 15, 2012 at 20:54

Oleksi · Accepted Answer · 2012-05-15 20:49:39Z

6

Technically, it's faster to not call the method multiple times, however this might not always be the case. The JVM might optimize the method calls to be inline and you won't see the difference at all. In any case, the difference is negligible.

However, it's probably safer to always use a getter. What if the value of the state changes between your calls? If you want to use a consistent version, then you can save the value from the first call. Otherwise, you probably want to always use the getter.

In any case, you shouldn't base this decision on performance because it's so negligible. I would pick one and stick with it consistently. I would recommend always going through your getters/setters.

answered May 15, 2012 at 20:49

Oleksi

13.1k5 gold badges58 silver badges81 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

yshavit Over a year ago

The JIT may do more than just inline it -- it could recognize that the value doesn't change within this thread (and that there are no happens-before edges to its changing in other threads), and thus put it into a CPU register. That's why code like while(this.getSomeBool()) { doSomething(); } can spin forever, even if some other thread changes someBool but in a non-threadsafe way.

emory Over a year ago

"However, it's probably safer to always use a getter." is simply not true. Without context, we can not know. Perhaps the correct behavior of algo is to perform the operations on the same value of something even if it changes.

Jörn Horstmann · Accepted Answer · 2012-05-15 21:44:44Z

1

Getters and setters are about encapsulation and abstraction. When you decide to invoke the getter multiple times, you are making assumptions about the inner workings of that class. For example that it does no expensive calculations, or that the value is not changed by other threads.

I'd argue that its better to call the getter once and store its result in a temporary variable, thus allowing you to freely refactor the implementing class.

As an anecdote, I was once bitten by a change where a getter returned an array, but the implementing class was changed from an array property to using a list and doing the conversion in the getter.

answered May 15, 2012 at 21:44

Jörn Horstmann

34.2k11 gold badges77 silver badges122 bronze badges

Comments

sjakubowski · Accepted Answer · 2012-05-15 20:49:45Z

0

The compiler should optimize either one to be basically the same code.

answered May 15, 2012 at 20:49

sjakubowski

2,94329 silver badges36 bronze badges

1 Comment

SomeKittens Over a year ago

That's an assumption that @John T. may not want to make.

Collectives™ on Stack Overflow

java - is initializing a temporary variable for simple getters better or not?

3 Answers 3

2 Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related