13

When I was learning Java standard edition, getter and setter functions were often used to hide variables and to reduce direct access to them. I have been told by several sources that in Android you should not use these functions and only modify the variables directly. The reason is that there is a performance loss due to overhead when using getters and setters is used in Android. Resulting in more memory use and slowing down the system.

Is there any truth to this? and if there is, why the performance loss for using getter and setter?

A--C
  • 36,351
  • 10
  • 106
  • 92
Kevik
  • 9,181
  • 19
  • 92
  • 148
  • 1
    According to [d.android](http://developer.android.com/training/articles/perf-tips.html#internal_get_set) you should avoid them. Good question! Although I must wonder, how much of a hit would my app take if I did the complete opposite of everything they suggest? – A--C Dec 19 '12 at 02:32
  • The docs do say to avoid them but I don't think the stress is significant in most cases. I use them occasionally to expose certain fields but you might want to just use them with the assumption that they do add some overhead. Keep the calls out of loops/process intensive blocks and you should be ok. – Chuck D Dec 19 '12 at 02:49

3 Answers3

9

As of the documentation found here using a getter and setter is a bad idea in android. As it says,

this is a bad idea on Android. 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.

Find more about performance here.

Vinay
  • 6,891
  • 4
  • 32
  • 50
  • 6
    To add to this: This points largely to *internal* getting and setting using this methodology when the method *is trivial*. For good programming practices, *external* calls to the values should be through getters and setters; and internal non-trivial getting and setting should be done through methods for the purpose of [DRY](http://en.wikipedia.org/wiki/Don't_repeat_yourself). – Cat Dec 19 '12 at 02:54
7

According to the performance tips provided by Google android team:

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.

However I do agree that a good coding practice is more important and the team also mentioned that:

Note that if you're using ProGuard, you can have the best of both worlds because ProGuard can inline accessors for you.

Therefore I think it's ok to use the getter and setter ;)

Reference

hungr
  • 2,086
  • 1
  • 20
  • 33
4

The performance loss for setters and getters is negligible. Public fields are bad practice and violate the object oriented principles of data encapsulation and information hiding.

Using a setter or getter requires one property call more than accessing the field directly. That's nothing, so don't worry about it--focus on writing good code.

edit:

To clarify, this is from the same android document that the other posters are quoting:

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.

In other words, you still need getters and setters. You just should try to avoid calling them from within the class that holds those methods since you have direct access to the field.

aleph_null
  • 5,766
  • 2
  • 24
  • 39
  • 3
    as stated in @hungr's answer, they performance is arguably not "negligible" (3-7X slower) in android, but otherwise your answer is spot on -- direct access inside the class, getter/setters for outside for all but trivial classes. – iagreen Dec 19 '12 at 02:44