Variables globales et variables locales sous Android

Les variables globales, comme leur nom l'indique, sont des variables qui peuvent être appelées dans la classe entière ou dans plusieurs fonctions. Également appelées variables externes. Les variables locales sont des variables accessibles dans une procédure ou une fonction spécifique. Il est très simple de déclarer une variable, mais lorsqu’il s’agit de l’utiliser, ce n’est pas aussi simple qu’on l’imagine. Quant à moi, je définis souvent des variables globales à utiliser, mais c'est justement pour cette raison que je définis des variables globales. Cela a également évité bien des rebondissements.

Lors de l'utilisation d'un adaptateur, l'adaptateur est généralement toujours utilisé avec listView, car un listView a essentiellement une disposition d'élément listView, le scénario suivant est le suivant : il y aura un ImageView dans chaque Article. Lorsque je clique sur un élément, je dois changer la couleur d'arrière-plan de l'ImageView de l'élément ou la remplacer par une autre image d'arrière-plan. Une situation qui peut se produire à ce moment-là est quelque chose que vous avez clairement souligné dans le premier article. vous constaterez que les images du troisième ou du deuxième article ont également changé. C'est parce que vous définissez une variable globale. La partie code est la suivante :

public class  Adapter extends BaseAdapter {
private ImageView img;

  public View getView(int position, View convertView, ViewGroup parent) {
  convertView = mInflater.inflate(R.layout.group_listview_item,null);
  img = (ImageView) convertView.findViewById(R.id.logo);

  return convertView;

  }
}

Dans la partie ci-dessus, ImageView est une variable globale. À ce stade, nous devons définir ImageView comme une variable locale

 public class  Adapter extends BaseAdapter {
 public View getView(int position, View convertView, ViewGroup parent) {
     convertView = mInflater.inflate(R.layout.group_listview_item,null);
     ImageView  img = (ImageView) convertView.findViewById(R.id.logo);
    return convertView;
  } 
}

qui représente à ce moment l'ImageView dans chaque élément. Une autre situation est que lorsque vous créez un panier, vous pouvez cliquer sur l'icône plus ou moins pour modifier le nombre d'articles dans le panier. Lorsque vous définissez le numéro de quantité, il doit également être défini comme variable locale. Ce serait mieux si vous pouviez utiliser ViewHolder.

Les variables statiques modifiées sont très pratiques à utiliser. Elles peuvent être utilisées dans différentes classes et packages et occupent une mémoire séparée dans la machine virtuelle. Oui, ce sont leurs avantages, mais une fois le projet lancé, uniquement pour. constatez que la statique présente certains inconvénients.

Lors de la vérification des informations de crash du projet, j'ai découvert qu'il y avait des erreurs d'exception de pointeur nul inexplicables à de nombreux endroits. Après enquête, j'ai découvert qu'il pouvait s'agir d'un problème statique. Dans le projet, nous avons enregistré les informations de l'utilisateur, c'est-à-dire l'objet User, dans une variable statique. Aux endroits où des erreurs ont été signalées, nous avons constaté que cette variable était utilisée. Nous pouvons donc en déduire grossièrement qu'il existe une certaine relation. avec cette façon de sauvegarder le contact. Dans le même temps, de nombreux utilisateurs ont signalé que lorsque l'application est ouverte, après avoir répondu à un appel téléphonique ou attendu longtemps, l'application plante à leur retour dans l'application. Ces plantages sont liés au pointeur nul des variables statiques. .

Dans ce cas, la modification statique est-elle très dangereuse dans le développement Android ? Peut-être pouvons-nous dire que s'il est défini comme utilisateur statique u = new User();, alors il ne devrait pas y avoir beaucoup de problème, mais s'il est défini comme utilisateur statique u;, alors NULL est susceptible de se produire. Bien entendu, les propriétés de la méthode précédente peuvent également être vides, mais cela peut être encapsulé pour éviter les pointeurs nuls. De plus, les constantes statiques restent très utiles.

Alors, comment devons-nous sauvegarder les informations de connexion ou globales ? Selon les recommandations officielles de Google et les recommandations des experts de Baidu, nous devrions essayer d'utiliser des classes personnalisées héritées d'Application, définir des variables qui doivent être utilisées globalement dans les classes dont nous héritons, et obtenir et enregistrer les variables pertinentes via getApplicationContext(). Juste des variables.

 /** 
     * 自定义的MyApplication继承Application 
     *  
     * @author way 
     *  
     */  
    public class MyApplication extends Application {  
        /** 
         * 引发异常：在一些不规范的代码中经常看到Activity或者是Service当中定义许多静态成员属性。这样做可能会造成许多莫名其妙的 null 
         * pointer异常。 
         */  
      
        /** 
         * 异常分析：Java虚拟机的垃圾回收机制会主动回收没有被引用的对象或属性。在内存不足时，虚拟机会主动回收处于后台的Activity或 
         * Service所占用的内存。当应用再次去调用静态属性或对象的时候，就会造成null pointer异常 
         */  
      
        /** 
         * 解决异常：Application在整个应用中，只要进程存在，Application的静态成员变量就不会被回收，不会造成null pointer异常 
         */  
        private int number;  
      
        @Override  
        public void onCreate() {  
            // TODO Auto-generated method stub  
            super.onCreate();  
        }  
      
        public int getNumber() {  
            return number;  
        }  
      
        public void setNumber(int number) {  
            this.number = number;  
        }  
    }

Cependant, pour que notre MyApplication remplace android.app.Application et prenne effet dans notre code, nous devons modifier AndroidManifest.xml :

   <application android:name=".MyApplication" ...>      
   </application>

Ci-dessous peut être utilisé de manière flexible dans Activité ou Service :

MyApplication application = (MyApplication) this.getApplicationContext();   
    //保存变量  
    application.setNumber(5);  
    //取出变量  
    application.getNumber();

L'application existe en même temps que l'application, c'est-à-dire que l'application est là et ne sera pas inexplicablement recyclée par le GC. Par conséquent, utilisez cette méthode. est plus sécurisé.