Join FlipAndroid.COM Telegram Group: https://t.me/joinchat/F_aqThGkhwcLzmI49vKAiw


Desempeño de Android: "Evita los internos y los setters"

Acaba de leer esto en el sitio de desarrollo:

Evite los Interruptores Internos

  • Crear cuenta de SIP de Android mediante programación
  • Cómo animar FloatingActionButton de la nueva biblioteca de soporte de diseño
  • Prueba de Android JUnit4
  • ¿Cómo acceder a EGL Image directamente desde Android Surface para su uso en el decodificador de video MediaCodec?
  • ArrayAdapter.getPosition (item) Returns ¿Qué?
  • Deshabilitar pan / zoom en com.google.android.maps.MapView
  • En lenguajes nativos como C ++ es práctica común utilizar getters (por ejemplo, i = getCount ()) en lugar de acceder al campo directamente (i = mCount). Este es un excelente hábito para C ++, ya que el compilador normalmente puede en línea el acceso, y si necesita restringir o depurar el acceso al campo, puede agregar el código en cualquier momento.

    En Android, esto es una mala idea. Las llamadas a métodos virtuales son costosas, mucho más que las búsquedas de instancia. Es razonable seguir prácticas comunes de programación orientada a objetos y tener getters y setters en la interfaz pública, pero dentro de una clase siempre debe tener acceso a los campos directamente.

    Sin un JIT, el acceso directo al campo es aproximadamente 3 veces más rápido que invocar un getter trivial. Con el JIT (donde el acceso directo al campo es tan barato como el acceso a un local), el acceso directo al campo es aproximadamente 7 veces más rápido que invocar un getter trivial. Esto es cierto en Froyo, pero mejorará en el futuro cuando el JIT inlines getter métodos.

    Así que está diciendo que usaría el acceso de campo dentro de la clase:

    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; } } 

    Pero ¿qué pasa con el acceso desde otro objeto ?

      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 } } 

  • ¿Cómo puedo separar los metadatos y la pista de un flujo de shoutcast sin realizar solicitudes separadas de metadatos y el streaming
  • Android Fragment no respeta a match_parent como altura
  • Getview Llamado varias veces en android
  • Android establece la gravedad de un TextView mediante programación
  • Crear archivo PDF / Word (Doc) en la aplicación
  • ¿Cómo puedo implementar la barra de acción personalizada con botones personalizados en Android?
  • 7 Solutions collect form web for “Desempeño de Android: "Evita los internos y los setters"”

    El éxito de rendimiento de utilizar getters y setters internos también se aplica a getters externos y setters.

    Sin embargo, en el caso externo los getters y setters tienen beneficios significativos en otras áreas; Por ejemplo preservando la encapsulación, reduciendo el acoplamiento dañoso, haciendo su código más mantenible, y así sucesivamente. Por lo tanto, es generalmente considerado como la mejor práctica para utilizar getters y setters a pesar del éxito de rendimiento que esto puede incurrir.

    El éxito de rendimiento es el resultado de las limitaciones de la generación actual de compiladores Android JIT más antiguos. Esta situación es segura para mejorar ha mejorado con Gingerbread. (Referencia – https://stackoverflow.com/a/4930538/139985 … y nota quién escribió esa respuesta!)

    En general, es una mala idea "afinar" su código para una plataforma inferior, especialmente si hay una posibilidad razonable de que una mejor está en el offing.

    Aunque b.innerObject es más rápido, a medida que avanza la tecnología (mejor cpus, JIT, etc) la diferencia entre las dos opciones se hace más pequeña.

    El único punto donde puede importar es cuando se hace en loops intensivos que se ejecutan todo el tiempo. Por ejemplo, en el método onDraw de un juego, cuando se realiza un bucle a través de cientos de objetos.

    Tenga en cuenta que las consideraciones de rendimiento sólo son relevantes si el miembro en cuestión se accede a miles de veces por segundo.

    Un buen ejemplo donde el acceso directo puede ser una buena idea es el escenógrafo de un juego ( 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 y Setters siempre tienen una sobrecarga ya que son llamadas de función. Cuando estás en el mismo objeto, puedes optimizar tu código sin usarlos como sabes para qué se utilizan y no necesitas abstraerlos / encapsularlos desde su propio objeto.

    Creo que también hay que mirarlo desde una perspectiva diferente:

    1. ¿No va a tener un getter / setter común oops prácticas? No querrás tener referencias directas si estás haciendo objetos / módulos que otros usarán.

    2. Realmente no quieres usar getters / setters demasiadas veces como al final, a menos que el sh! * Optimizado fuera de él las llamadas de la función tendrá sobrecarga.

    Usted realmente necesita para optimizar en una base percase, si estoy construyendo dos módulos donde algunos componentes sólo se accede por el otro yo podría hacer un campo estático de otro modo me quedo con getters / setters

    En cuanto a rendimiento, no hay diferencia en el acceso a este this.field o that.field .

    La sensación de que un campo de instancia es más accesible para el objeto que lo aloja es sólo una ilusión de sintaxis.

    OO sabio, en serio, lo complejo que puede convertirse en una aplicación para Android? Muchos de los mantras de OO provienen de la creación de aplicaciones monstruosas. ¿Cuál es el gran problema si su pequeña aplicación utiliza objetos como structs?

    E incluso en una aplicación enorme, siempre y cuando esté en casa, y todo el código fuente que accede a un campo están disponibles para la refactorización, no hay ningún problema en absoluto la exposición de los campos.

    Para el registro, otro problema con setter y getter (en Java) es que son dolorosos feo de usar.

    Digamos que el siguiente ejercicio, tenemos que modificar un campo de información privilegiada un campo de un objeto

    En java es:

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

    Mientras que en C # el mismo código es (incluso con encapsulación)

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

    Por lo tanto, el uso de campo público en Java (o android) es mucho más limpio:

      object.field.subfield.field3="hello"; // fine too 
    FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.