Question

I know rule #1 of optimization is: don’t do it! But I figured this was an easy question, and if I start using the faster method now I can save a lot of cpu time when I’m finished.

I’m making an RPG, and let’s say this is part of a custom class:

public class Baddie{

    int health;
    int magic;

    public Baddie(int health, int magic){
        this.health = health;
        this.magic = magic;
    }

    public int getHealth(){
        return health;
    }

Now, the answer to my question may be “there’s no difference” and that’s fine with me.. I just want to know. Is it quicker to get the Baddie’s health using field access:

//Somewhere in the main thread, I get an instance of Baddie..
Baddie b = getScaryBadGuy();
int baddieHealth = b.health;

Or is it quicker to use a return method?

int baddieHealth = b.getHealth();

Answer 1

Copied and pasted from Designing for Performance:

Avoid Internal Getters/Setters

In native languages like C++ it’s
common practice to use getters (e.g. i
= getCount()) instead of accessing the field directly (i = mCount). This is
an excellent habit for C++, because
the compiler can usually inline the
access, and if you need to restrict or
debug field access you can add the
code at any time.

On Android, this is a bad idea.
Virtual method calls are expensive,
much more so than instance field
lookups. It’s reasonable to follow
common object-oriented programming
practices and have getters and setters
in the public interface, but within a
class you should always access fields
directly.

Without a JIT, direct field access is
about 3x faster than invoking a
trivial getter. With the JIT (where
direct field access is as cheap as
accessing a local), direct field
access is about 7x faster than
invoking a trivial getter. This is
true in Froyo, but will improve in the
future when the JIT inlines getter
methods.