Android Performance - 'Avoid Internal Getters/Setters'

Just read this on the dev site:

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 开发者_如何学Pythonwithin 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.

Update in 2019/05: In the current version, the above material has been removed from the document!

So is it saying you would use field access within the class:

 public class MyObject {

    public Object innerObject; // This would be private if I was using a getter

    public void doSomeStuff(){
          if(innerObject){        // Within class access like this
                 // ....
          }
    }

    public Object getInnerObject(){  // This would be removed if I was using field access
         return innerObject;
    }
 }

But what about access from another object?:

 public class SecondObject {

      public void doSecondSomething(){
                MyObject ob = new MyObject();
                Object inner;

                //This is my question basically (from an Android performance perspective)   
                inner = ob.getInnerObject();
                // OR 
                inner = b.innerObject

       }

 }

The performance hit of using internal getters and setters also applies to external getters and setters.

However, in the external case the getters and setters have significant benefits in other areas; e.g. preserving encapsulation, reducing harmful coupling, making your code more maintainable, and so on. So, it is generally regarded as best practice to use getters and setters despite the performance hit that this may incur.

The performance hit is a result of limitations of older Android JIT compilers. This situation improved significantly with Gingerbread (see - https://stackoverflow.com/a/4930538/139985 ... and note who wrote that answer!) and continues to improve. Indeed, in the current (2019) version of the Performance Tips, the entire section advising about internal getters and setters has been removed.

In general, it is a bad idea to "tune" your code for an inferior platform, especially if there is a reasonable chance that a better one is in the offing.

Although b.innerObject is faster, as the technology advances (better cpus, JIT, etc) the difference between the two options gets smaller.

The only point where it may matter is when done in intensive loops that are executed all the time. For example, in the onDraw method of a game, when you loop through hundreds of objects.

Keep in mind that those performance considerations are relevant only if the member in question is accessed thousands of times per second.

A good example where direct access may be a good idea is the scenegraph of a game (libgdx)

public abstract class Actor {
    public Group parent;
    public final String name;
    public boolean touchable = true;

    public float x;
    public float y;
    public float width;
    public float height;
    public float originX;
    public float originY;
    public float scaleX = 1;
    public float scaleY = 1;
    public float rotation;
    public final Color color = new Color(1, 1, 1, 1);

// this is faster
inner = b.innerObject

// but this won't hurt performance much because
// it's assumed that it will be rare
inner = ob.getInnerObject();

Getters and Setters always have an overhead as they are function calls. When you are in the same object you can optimize your code by not using them as you know what they are used for and you don't need to abstract/encapsulate them from its own object.

I think you also need to look at it from a different perspective:

1. Will a not having a getter/setter break common oops practices ? You will not want to have direct references if you are making objects/modules that others will use.

2. You really don't want to use getters/setters too many times as in the end , unless the sh!* its optimized out of it function calls will have overhead.

You really need to optimize on a percase basis , if I am building two modules where some components are only accessed by each other I might make a static field else I will stick to getters/setters

Performance wise, there is no difference in accessing this.field or that.field.

The feeling that an instance field is more accessible to the object hosting it is just a syntax illusion.

OO wise, seriously, how complex can an Android app become? Many of the OO mantras are from building monster apps. What's the big deal if your little app uses objects like structs?

And even in a huge app, as long as it's in house, and all source code accessing a field are available for refactoring, there is no problem at all exposing the fields.

For the record, another problem with setter and getter (in Java) is they are painful ugly to use.

Let's say the next exercise, we need to modify a field insider a field of a object

In java is:

   object.getField().getSubField().setField3("hello"); // ugly

While in C# the same code is (even with encapsulation)

   object.Field.SubField.Field3="hello";  // fine

So, using public field in Java (or android) is a lot cleaner :

  object.field.subfield.field3="hello"; // fine too