Pourquoi les Android préfèrent-ils les cours statiques?

Je vois beaucoup de code java où Android préfère que les développeurs utilisent des classes intérieures statiques. Particulièrement pour les motifs comme le Pattern ViewHolder dans ListAdapters personnalisés.

Je ne sais pas quelles sont les différences entre les classes statiques et non statiques. J'ai lu à propos de cela, mais cela ne semble pas logique lorsqu'il s'agit d'une performance ou d'une empreinte mémoire.

  • Comment puis-je définir le titre de manière programmée
  • Qu'est-ce qui diffère entre getContext et GetActivity de Fragment dans la bibliothèque de support?
  • Comment superposer une image ou une vue sur une image capturée par une caméra
  • Comment personnaliser le code généré lorsque j'utilise "Surround with try / catch"?
  • La meilleure façon de déboguer les messages d'erreur de réaménagement
  • Inclure .so library dans apk dans android studio
  • Impossible de mettre à jour Android studio de 2.0 à 2.1
  • Comment afficher la liste des sons de notification disponibles sur Android
  • Modifier un AndroidManifest lors de la compilation pour supprimer la clé API
  • Android Google Connectez-vous: vérifiez si l'utilisateur est connecté
  • Est-ce possible de vérifier si une émission a été envoyée en mode collant? Peut-il être interrompu / supprimé?
  • Appelez le sujet principal du fil secondaire en Java / Android
  • 5 Solutions collect form web for “Pourquoi les Android préfèrent-ils les cours statiques?”

    Ce ne sont pas seulement les développeurs d'Android …

    Une classe interne non statique conserve toujours une référence implicite à l'objet clos. Si vous n'avez pas besoin de cette référence, tout ce qu'il fait, c'est la mémoire des coûts. Considère ceci:

    class Outer { class NonStaticInner {} static class StaticInner {} public List<Object> foo(){ return Arrays.asList( new NonStaticInner(), new StaticInner()); } } 

    Lorsque vous compilez, ce que vous obtenez sera quelque chose comme ceci:

     class Outer { Outer(){} public List<Object> foo(){ return Arrays.asList( new Outer$NonStaticInner(this), new StaticInner()); } } class Outer$NonStaticInner { private final Outer this$0; Outer$NonStaticInner(Outer enclosing) { this$0 = enclosing; } } class Outer$StaticInner { Outer$StaticInner(){} } 

    La principale différence entre les classes internes statiques et non statiques est qu'une classe interne non statique a accès à d'autres membres de la classe externe, même si elles sont privées. Les classes internes non statiques sont une "partie" de la classe externe. Vous ne pouvez pas créer, ni être en mesure d'exister sans une instance d'une classe externe. Une conséquence de ceci est qu'une instance d'une classe interne non statique est détruite lorsque l'instance de la classe externe est détruite.

    Les classes intérieures statiques, d'autre part, ressemblent à des cours extérieurs normaux. Les personnes vivantes et elles meurent elles-mêmes. Vous n'avez pas besoin d'une instance de la classe externe pour que la classe interne existe. Cela signifie qu'ils ont aussi leur propre cycle de vie. Ils se détruisent lorsque le collecteur d'ordures décide de les détruire.

    Comment cela affecte-t-il la mémoire et / ou la performance? Je ne sais vraiment pas. 🙂

    Les classes intérieures statiques (c'est-à-dire les classes déclarées dans une autre classe avec mot-clé static ) sont assez semblables aux classes "normales" sauf que vous ne polluez pas l'espace de nom de votre paquet. C'est leur (seulement) différence et bénéfice et je crois que c'est la raison pour laquelle vous le voyez dans Android.

    Utilisez des classes internes statiques lorsque le but de la classe est de resserrer à la classe principale, mais ne dépend pas de ses instances. Ceci est généralement considéré comme une bonne pratique.

    Si vous décompilez une classe interne (ou la regardez à l'aide du débogueur), vous pouvez voir qu'il existe un code généré pour accéder à l'instance de la classe externe qui a été utilisée pour les créer. Les frais généraux pour cela sont plus de mémoire pour le pointeur supplémentaire, plus de processeur pour la collecte des ordures en raison d'un pointeur supplémentaire pour tester, et si vous voulez choisir nit, plus de temps de compilation. La création d'instances de classes internes non statiques est un peu plus compliquée car vous avez besoin d'une instance de la classe externe pour les créer.

    La visibilité des classes intérieures statiques et non statiques peut être contrôlée. Habituellement, ils sont privés si leur implémentation est fortement liée aux détails internes de la classe externe, et le développeur ne pense pas que le code peut être réutilisé. En ce sens, ils ne sont pas meilleurs que les fonctions privées. Les classes internes peuvent être publiques dans des cas comme Map.Entry, où la classe interne est fortement connectée à l'interface exposée par la classe et le développeur ne pense pas que Map.Entry puisse être utilisé sans une sorte de carte. Les deux types ont accès à des membres privés de la classe externe et la classe externe a accès à des membres privés de la classe intérieure.

    Les instances de classes internes statiques et non statiques sont collectées comme toutes les autres classes. Il n'y a pas de lien spécial entre la collection de saisie de la classe externe et la collecte des ordures de la classe intérieure.

    Dans le cas de la mise en œuvre des classes UI comme swing ou Android, vous verrez des classes intérieures statiques car elles sont traitées comme une fonction privée. Ces classes ne sont pas développées pour une réutilisation en dehors de la classe externe et sont fortement liées à la mise en œuvre interne de la classe externe. Il n'y a aucune raison de les exposer et de s'assurer qu'ils peuvent fonctionner dans plus de cas que le contexte spécifique des exigences de classe externe.

    Une instance de classe interne non statique contient une référence à l'instance de classe externe alors qu'une instance de classe interne statique ne l'est pas.

    Ceci est pertinent pour l'empreinte de la mémoire des applications car la référence cachée peut entraîner des fuites de mémoire – le collecteur d'ordures ne peut pas collecter l'instance de classe externe jusqu'à ce qu'il n'existe plus de références. En outre, la référence supplémentaire elle-même nécessite une mémoire, cela peut être pertinent si un nombre élevé d'instances sont utilisées.

     class Outer{ class Inner{//Only works with non static inner class public Outer getOuter(){return Outer.this;} } } 

    Il est également pertinent pour son utilisation, la référence à la classe externe est un argument ctor de la classe interne, pour créer un nouvel objet de classe interne non statique, vous devez appeler le ctor comme une fonction de membre sur une instance de la classe externe ou de Dans une fonction membre de la classe externe. Cela signifie que vous ne pouvez pas avoir une instance de la classe interne sans une instance de la classe externe.

     Outer.Inner in = new Outer().new Inner(); 
    coAndroid est un fan Android de Google, tout sur les téléphones Android, Android Wear, Android Dev et Android Games Apps.