'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 (eg 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.
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; eg 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 the current generation of older Android JIT compilers. This situation is sure to improve has improved with Gingerbread. (Reference - https://stackoverflow.com/a/4930538/139985 ... and note who wrote that answer!)
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);
上一篇: 有没有办法在Eclipse中自动生成getter和setter？
下一篇: '避免内部吸收者/安装者'