`static` y` non-static` campos para un mejor rendimiento en java Android
Desarrollo el juego con openGL 2D en Android.
Es muy impotente para ganar el nivel de rendimiento ya que mi vista es complicada y contiene 300-400 objetos al mismo tiempo (bucle de juego).
- Retrolambda en Travis CI
- Android: Necesito una vista previa circular de la cámara. ¿Cómo lograrlo?
- Proguard elimina clase Anonymous en clase Anonymous en Java
- Cómo almacenar Hashmap en Android para que se reutilice cuando la aplicación se reinicie con las preferencias compartidas?
- ¿Cómo hacer un temporizador simple sin nueva clase en Android?
Sé bastante bien sobre campos static
y non-static
en java:
private final static int NUMBER = 10;
y
private final int NUMBER = 10;
Mi pregunta no es la encapsulación (como OO) sino el rendimiento.
¿Qué es mejor utilizar para el rendimiento, campos static
o non-static
.
La idea es que para la mayoría de mi lógica uso primitivos como float/int
.
Crear genérico super clase para todos mis "vistas" y esta clase debe ser más eficiente en el ámbito de rendimiento:
He aquí un ejemplo:
/** Sprite sheet definition */ private final int SPRITE_WIDTH = 4; private final int SPRITE_HEIGHT = 4; private float mScreenWidth, mScreenHeight, wRatio, hRatio; private int mFrame = 0; private int mSwitcher = 0; private final int TEXTURE_COUNT = 1; // for sprite sheet we use 1 image all the time. private int[] textures = new int[TEXTURE_COUNT]; // frame animation protected FloatBuffer vertexBuffer; private final ESpriteDirection mDirection = ESpriteDirection.TOP_TO_DOWN_LEFT_TO_RIGHT; public float x, y, initPos, finalPos, initSpeed, currentPos; private ByteBuffer bb1; private final int TOTAL_IMAGE_COUNT_IN_SPRITE = SPRITE_WIDTH * SPRITE_HEIGHT; private FloatBuffer[] floatBufferArray = new FloatBuffer[TOTAL_IMAGE_COUNT_IN_SPRITE]; private float xOffset = 1.0f/SPRITE_WIDTH; private float yOffset = 1.0f/SPRITE_HEIGHT; private float vertices[] = { 0.0f,3.0f,0.0f, 0.0f,0.0f,0.0f, 3.0f,3.0f,0.0f, 3.0f,0.0f,0.0f }; private float storage[][] = new float[TOTAL_IMAGE_COUNT_IN_SPRITE][]; private int[] sprite_X_Indexes = new int[SPRITE_WIDTH];//{1,2,3,4}; private int[] sprite_Y_Indexes = new int[SPRITE_WIDTH];//{1,2,3,4};
Puedo adivinar que para la iniciación múltiple de la misma clase static
campo static
es mejor, hmm
Gracias,
- No se puede convertir una representación en un objeto de clase java.lang.String
- Dibujo sobre lienzo y varios objetos de pintura
- Cómo establecer el valor predeterminado de un ListPreference
- Los caracteres árabes en String.Format ("% d", 1, Locale.US)
- Cómo agregar controles personalizados a MapFragment en Google Maps Android API v2?
- ¿Por qué mi aplicación Android salta los marcos cuando se llama a Thread.sleep?
- No se puede capturar Java (Android) Excepción con try-catch
- Manejo del componente de la daga en el cambio de orientación
Desde un punto de vista de rendimiento, una vez que el código se ha compilado debe haber bastante poca diferencia, ya que tanto su estática y un (no) único campo estático se han transformado en sólo una ubicación de memoria.
Declarar el campo estático puede proporcionar algunas posibilidades de optimización en el nivel del compilador. Por otro lado, los objetos típicamente estáticos probablemente no están "cerca" de los datos de la instancia en la memoria, lo cual es malo para el rendimiento de la memoria caché.
En general, esto no es donde debe pasar su tiempo hasta que / a menos que haya agotado todas las optimizaciones algorítmicas, y luego sólo después de saber que esto es realmente donde pierdes tiempo.