Variables globales en Java : quand les utiliser ?

Bonjour! Dans cet article, nous parlerons des variables globales, de leur déclaration et des exemples d'utilisation appropriée. Une petite remarque : nous ne considérerons pas les variables de classe globales, c'est-à-dire celles accessibles au sein d'une même classe. Nous parlerons des variables globales de l'ensemble de l'application - celles accessibles dans l'ensemble de l'application.

Comment créer des variables globales

Les variables globales sont des variables accessibles depuis n'importe où dans l'application. En d’autres termes, leur portée s’étend à l’ensemble de l’application. Pour créer une telle variable en Java, vous devez créer une variable statique publique dans une classe publique :

public class Example {
    public static int a;
    public static int b;
    public static String str;
}

Les variables a, bet str- sont devenues globales. Nous pouvons y accéder directement depuis d'autres classes à l'intérieur de l'application :

public class GlobalVarsDemo {
    public static void main(String[] args) {
        Example.a = 4;
        Example.b = 5;
        Example.str = "Global String variable value";

        System.out.println(Example.a);
        System.out.println(Example.b);
        System.out.println(Example.str);
    }
}

Si nous exécutons la méthode main, nous verrons le résultat suivant :

4
5
Global String variable value

Les variables globales peuvent être divisées en 2 types :

• variables pouvant être modifiées ;
• variables qui ne peuvent être lues.

Ces dernières sont appelées constantes globales. Afin de créer une constante globale, vous devez créer une variable finalet lui attribuer une valeur lors de la définition de la variable :

public class Constants {
    
    public static final double PI = 3.1415926535897932384626433832795;
    public static final String HELLO_WORLD_STR = "Hello, World!";
    
}

Selon la convention de dénomination Java, toutes les constantes doivent être nommées en majuscules, en séparant les mots par un caractère de soulignement. Nous avons donc créé des constantes, et désormais nous ne pourrons plus modifier leurs valeurs : Cependant, nous pouvons lire leurs valeurs :

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println(Constants.HELLO_WORLD_STR);
    }
}

Conclusion:

Hello, World!

public class ConstantsDemo {
    public static void main(String[] args) {
        double r = 10;
        String message = String.format("Площадь круга с радиусом %f=%f", r, getCircleSquare(r));
        System.out.println(message);

    }

    static double getCircleSquare(double r) {
        return Constants.PI * r * r;
    }
}

Conclusion:

Площадь круга с радиусом 10,000000=314,159265

Faut-il utiliser des variables globales ?

Il existe de nombreux articles sur Internet dont le message principal est le suivant : les variables globales sont mauvaises, mauvaises et terribles. Est ce que c'est vraiment? Essayons de donner les avantages et les inconvénients des variables globales afin que chacun puisse tirer sa propre conclusion. Commençons par les inconvénients. Imaginons une application possédant une classe avec des variables globales pouvant être lues et modifiées. Au fil du temps, le nombre de classes dans le projet, le nombre de variables globales et de méthodes qui utilisent des variables globales, ou en d'autres termes, qui en dépendent, augmentent. Au fil du temps, chaque variable globale est lue dans différentes parties du système à des fins différentes. Dans différentes parties du système, la valeur d'une variable peut être mise à jour. L'image globale du monde de cette application devient beaucoup plus compliquée, ce qui entraîne les inconvénients suivants :

1. Lisibilité réduite et difficulté accrue à comprendre le code.
2. Complexité accrue de la maintenance du code.
3. Pour modifier une variable globale, il est nécessaire d'analyser l'intégralité du code afin de ne pas définir la variable sur une valeur invalide pour d'autres parties du système.
4. Augmentation des erreurs très difficiles à déboguer.

   Imaginons une variable globale, un tableau d'objets. Dans une partie du système, par exemple, des chaînes sont attendues dans ce tableau, et dans une autre partie du système, quelqu'un a décidé d'utiliser des nombres à virgule flottante. Il est peu probable que quiconque veuille comprendre cela.

5. Les noms de variables peuvent être les mêmes si vous utilisez des variables globales dans votre code, ainsi que certaines bibliothèques qui, à leur tour, utilisent également des variables globales. Cela peut entraîner des erreurs tant du côté de votre application que du côté de la bibliothèque que vous utilisez.
6. Augmente la connectivité entre les différentes parties du système qui utilisent des variables globales. Au contraire, vous devez vous efforcer d’obtenir un couplage lâche du code. Il est préférable d'avoir de nombreux petits sous-systèmes vaguement connectés les uns aux autres plutôt que d'avoir un seul objet volumineux. Parce qu’il est plus facile pour le cerveau de gérer plusieurs choses simples qu’une seule chose trop complexe et déroutante.
7. L'écriture de tests unitaires devient plus difficile car le test ne sait pas quelles variables globales sont nécessaires et comment elles doivent être initialisées.
8. Dans les applications multithread, l'utilisation de variables globales par différents threads entraîne une augmentation des erreurs difficiles à déboguer et une augmentation de la complexité des projets. Pour cette raison, il est nécessaire de configurer plus correctement l'accès à ces variables, en les équipant de synchronisations et de verrous. Cela pourrait conduire à des courts-circuits à l’avenir. Par exemple, le thread A a verrouillé la variable X pour son travail, et le thread B a verrouillé la variable Y pour son travail, et le thread A a maintenant besoin de la variable Y et le thread B a besoin de la variable X. En conséquence, le programme se bloquera.

Mais tout cela est inexact. Il s'agit d'une description des risques dont la probabilité augmente avec la croissance du projet et l'augmentation du nombre de variables globales qu'il contient. Passons aux pros :

1. Dans les petits projets, les variables globales sont la chose la plus simple pour faire fonctionner le projet.
2. Parfois, la peur d’utiliser des variables globales conduit à une complexité encore plus grande du projet. Les programmeurs commencent ensuite à créer des singletons et à recourir à d’autres modèles de conception.
3. En programmation, vous devez souvent vous appuyer sur des valeurs immuables.

   Le plus raisonnable est d'écrire ces valeurs sous forme de constante, car seules les constantes garantissent que la valeur d'une variable ne changera pas dans le temps. De telles constantes peuvent être trouvées à tout moment ( Integer.MAX_VALUE, Integer.MIN_VALUE, Boolean.TRUE, Collections.EMPTY_LISTetc.). Mais la programmation ne se limite pas à l’utilisation de bibliothèques standards. Il arrive souvent que vous deviez écrire une sorte de logique unique, qui devra s'appuyer sur vos propres constantes uniques. C'est pourquoi parfois, l'utilisation de constantes (variables globales en lecture seule) facilite vraiment la vie.

En général, vous ne devez pas abuser des variables globales ; si possible, utilisez uniquement des constantes. Il a été dit plus tôt que l'utilisation de variables globales dans de petits projets n'était pas une mauvaise chose. Mais il est préférable pour un développeur novice de ne pas les utiliser du tout. Pour deux raisons :

1. Tout ce qu'écrit un développeur novice est essentiellement un petit projet. Et utiliser des variables globales dans ses projets lui apprendra à utiliser des variables globales partout.
2. Il vaut mieux d'abord apprendre à se passer des « trucs interdits ». Et avec l’expérience, la compréhension du moment opportun pour utiliser de telles techniques viendra d’elle-même.