Types de variables Java

Dans le langage Java, toutes les variables doivent être déclarées avant de pouvoir être utilisées.

Le format de base pour déclarer une variable est le suivant :

type identifier [ = value][, identifier [= value] ...] ;

Description du format :

  • type -- le type de données.
  • identificateur -- est le nom de la variable, et des virgules peuvent être utilisées,pour séparer et déclarer plusieurs variables du même type.

Ce qui suit présente quelques exemples de déclarations de variables. Notez que certains incluent un processus d'initialisation.

int a, b, c;         //Déclarez trois entiers int : a, b, c int d = 3, e = 4, f = 5; //Déclarez trois entiers et attribuez des valeurs initiales byte z = 22;         //Déclarez et initialisez z String s = "example"; //Déclarez et initialisez la chaîne de caractères s double pi = 3.14159; //Déclaration d'une variable à virgule flottante en double précision pi char x = 'x';        //Déclarez la variable x avec la valeur du caractère 'x'.

Les types de variables pris en charge par le langage Java sont :

  • Variables locales :Les variables locales sont des variables déclarées à l'intérieur d'une méthode, d'un constructeur ou d'un bloc. Elles sont détruites lorsque la méthode, le constructeur ou le bloc dans lequel elles sont déclarées termine son exécution. Les variables locales doivent être initialisées lors de leur déclaration ; sinon, une erreur de compilation se produira.

    public void exampleMethod() {
    int localVar = 10; // 局部变量
    // ...
}

  • Variables d'instance :Les variables d'instance sont déclarées dans une classe mais en dehors des méthodes, des constructeurs ou des blocs. Elles appartiennent aux instances de la classe, et chaque instance de la classe possède sa propre copie. Si elles ne sont pas explicitement initialisées, les variables d'instance reçoivent des valeurs par défaut (0 pour les types numériques, false pour les booléens, null pour les types de référence d'objet).

    public class ExampleClass {
    int instanceVar; // 实例变量
}

  • Variables statiques ou variables de classe :Les variables de classe sont des variables déclarées avec le mot-clé static dans une classe. Elles appartiennent à la classe plutôt qu'aux instances. Toutes les instances de la classe partagent la même valeur de variable de classe. Les variables de classe sont initialisées lors du chargement de la classe, et ne sont initialisées qu'une seule fois.

    public class ExampleClass {
    static int classVar; // 类变量
}

  • Paramètres :Les paramètres sont des variables dans les déclarations de méthode ou de constructeur, utilisées pour recevoir les valeurs transmises lors de l'appel de la méthode ou du constructeur. La portée des variables de paramètre est limitée à l'intérieur de la méthode.

    public void exampleMethod(int parameterVar) {
    // 参数变量
    // ...
}

L'exemple suivant définit une classe ExampleTest, qui contient une variable membre instanceVar et une variable statique staticVar.

Dans la méthode method(), une variable de paramètre paramVar et une variable locale localVar sont définies. À l'intérieur de la méthode, nous attribuons la valeur de la variable locale à la variable membre, attribuons la valeur de la variable de paramètre à la variable statique, puis affichons les valeurs de ces variables.

Dans la méthode main(), nous créons un objet ExampleTest et appelons sa méthode method().

Exemple

public class ExampleTest { //Variable membre private int instanceVar; //Variable statique private static int staticVar; public void method(int paramVar) { //Variable locale int localVar = 10; //Utilisation des variables instanceVar = localVar; staticVar = paramVar; System.out.println("Variable membre :" + instanceVar); System.out.println("Variable statique :" + staticVar); System.out.println("Variable de paramètre :" + paramVar); System.out.println("Variable locale :" + localVar); } public static void main(String[] args) { ExampleTest v = new ExampleTest(); v.method(20); } }

Exécutez le code ci-dessus, et la sortie est la suivante :

成员变量: 10
静态变量: 20
参数变量: 20
局部变量: 10

Variables de paramètre Java

Les variables de paramètre en Java sont des variables déclarées dans des méthodes ou des constructeurs, utilisées pour recevoir les valeurs transmises à la méthode ou au constructeur. Les variables de paramètre sont similaires aux variables locales, mais elles n'existent que lorsque la méthode ou le constructeur est appelé et ne peuvent être utilisées qu'à l'intérieur de la méthode ou du constructeur.

La syntaxe de déclaration d'une méthode Java est la suivante :

accessModifier returnType methodName(parameterType parameterName1, parameterType parameterName2, ...) {
    // 方法体
}
  • parameterType -- représente le type de la variable de paramètre.
  • parameterName -- représente le nom de la variable de paramètre.

Lors de l'appel d'une méthode, nous devons transmettre des valeurs aux variables de paramètre ; ces valeurs peuvent être des constantes, des variables ou des expressions.

Il existe deux façons de passer des valeurs aux variables de paramètre de méthode :Passage par valeuretPassage par référence。

  • Passage par valeur :Lorsqu'une méthode est appelée, une copie de la valeur du paramètre réel est transmise. Lorsqu'une nouvelle valeur est affectée à la variable de paramètre, seule la valeur de la copie est modifiée, et la valeur d'origine n'est pas affectée. Les types de données de base en Java utilisent le passage par valeur pour transmettre les valeurs des variables de paramètre.

  • Passage par référence :Lorsqu'une méthode est appelée, une référence (c'est-à-dire une adresse mémoire) au paramètre réel est transmise. Lorsqu'une nouvelle valeur est affectée à la variable de paramètre, le contenu de la valeur d'origine est modifié. Les types objet en Java utilisent le passage par référence pour transmettre les valeurs des variables de paramètre.

Voici un exemple simple illustrant l'utilisation des variables de paramètre de méthode :

Exemple

public class ExampleTest {
    public static void main(String[] args) {
        int a = 10, b = 20;
        swap(a, b); // Appeler la méthode swap
        System.out.println("a = " + a + ", b = " + b); // Afficher les valeurs de a et b
    }
   
    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
    }
}

Exécutez le code ci-dessus, et la sortie est la suivante :

a = 10, b = 20

Variables locales en Java

Les variables locales en Java sont des variables déclarées à l'intérieur d'une méthode, d'un constructeur ou d'un bloc d'instructions, et leur portée est limitée au bloc de code dans lequel elles sont déclarées.

La syntaxe de déclaration des variables locales est :

type variableName;
  • type -- représente le type de la variable.
  • variableName -- représente le nom de la variable.

Description:

  • Portée: La portée d'une variable locale est limitée à la méthode, au constructeur ou au bloc de code dans lequel elle est déclarée. Une fois que le flux d'exécution quitte cette portée, la variable locale n'est plus accessible.

  • Cycle de vie: Le cycle de vie d'une variable locale commence lorsqu'elle est déclarée et se termine lorsque la méthode, le constructeur ou le bloc de code termine son exécution. Ensuite, la variable locale sera récupérée par le ramasse-miettes.

  • Initialisation: Les variables locales doivent être initialisées avant utilisation. Si elles ne sont pas initialisées, le compilateur signalera une erreur car Java ne fournit pas de valeurs par défaut pour les variables locales.

  • Déclaration: Les variables locales doivent être déclarées au début d'une méthode ou d'un bloc de code. Lors de la déclaration, vous pouvez spécifier le type de données, suivi du nom de la variable, par exemple :int count;。

  • Affectation: Une variable locale doit recevoir une valeur après sa déclaration avant de pouvoir être utilisée dans la méthode. L'affectation peut être une affectation directe, ou passer par un appel de méthode ou une expression.

  • Restrictions: Les variables locales ne peuvent pas être directement accessibles par les autres méthodes de la classe ; elles sont propres à la méthode ou au bloc de code dans lequel elles sont déclarées.

  • Gestion de la mémoire: Les variables locales sont stockées sur la pile de la machine virtuelle Java (JVM), contrairement aux variables d'instance ou aux objets, qui sont stockés sur le tas.

  • Ramasse-miettes: Étant donné que le cycle de vie des variables locales est strictement limité à l'exécution d'une méthode ou d'un bloc de code, elles ne sont plus référencées après la fin de l'exécution de la méthode ou du bloc de code. Par conséquent, le ramasse-miettes de la JVM récupère automatiquement la mémoire qu'elles occupent.

  • Réutilisation: Les noms des variables locales peuvent être réutilisés dans différentes méthodes ou blocs de code, car leur portée est locale et ne provoque pas de conflits de nommage.

  • Paramètres et valeurs de retour: Les paramètres de méthode peuvent être considérés comme un type spécial de variable locale. Ils sont initialisés lors de l'appel de la méthode, et leur cycle de vie se termine après le retour de la méthode.

Exemple

L'exemple suivant est un exemple simple démontrant l'utilisation de variables locales :

Exemple

public class LocalVariablesExample {
    public static void main(String[] args) {
        int a = 10; // Déclaration et initialisation de la variable locale a
        int b;     // Déclaration de la variable locale b
        b = 20;    // Initialisation de la variable locale b
       
        System.out.println("a = " + a);
        System.out.println("b = " + b);
       
        // Si une variable locale n'est pas initialisée avant utilisation, le compilateur signalera une erreur
        // int c;
        // System.out.println("c = " + c);
    }
}

Dans l'exemple ci-dessus, nous avons déclaré et initialisé deux variables locales a et b, puis affiché leurs valeurs. Notez que si vous n'initialisez pas une variable locale avant de l'utiliser, le compilateur signalera une erreur.

Dans l'exemple suivant, age est une variable locale définie dans la méthode pupAge(), et sa portée est limitée à cette méthode :

package com.example.test; public class Test{ public void pupAge(){ int age = 0; age = age + 7; System.out.println("L'âge du chiot est :" + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

Le résultat de compilation et d'exécution de l'exemple ci-dessus est le suivant :

小狗的年龄是: 7

Dans l'exemple suivant, la variable age n'est pas initialisée, donc une erreur de compilation se produit :

package com.example.test; public class Test{ public void pupAge(){ int age; age = age + 7; System.out.println("L'âge du chiot est :" + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

Le résultat de compilation et d'exécution de l'exemple ci-dessus est le suivant :

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

Variables membres (variables d'instance)

  • Les variables membres sont déclarées dans une classe, mais en dehors des méthodes, des constructeurs et des blocs d'instructions.
  • Lorsqu'un objet est instancié, la valeur de chaque variable membre est déterminée en conséquence.
  • Les variables membres sont créées lorsque l'objet est créé et détruites lorsque l'objet est détruit.
  • Les valeurs des variables membres doivent être référencées par au moins une méthode, un constructeur ou un bloc d'instructions, afin que le code externe puisse obtenir des informations sur les variables d'instance par ces moyens.
  • Les variables membres peuvent être déclarées avant ou après leur utilisation.
  • Les modificateurs d'accès peuvent modifier les variables membres.
  • Les variables membres sont visibles par les méthodes, les constructeurs ou les blocs d'instructions de la classe. En général, les variables membres doivent être définies comme private. En utilisant des modificateurs d'accès, les variables membres peuvent être rendues visibles aux sous-classes.
  • Les variables membres ont des valeurs par défaut. La valeur par défaut des variables numériques est 0, celle des variables de type boolean est false, et celle des variables de type référence est null. La valeur d'une variable peut être spécifiée au moment de la déclaration ou dans le constructeur.
  • Les variables membres peuvent être accessibles directement par leur nom de variable. Cependant, dans les méthodes statiques et les autres classes, vous devez utiliser le nom pleinement qualifié :ObjectReference.VariableName。

La syntaxe de déclaration des variables membres est :

accessModifier type variableName;
  • accessModifier -- Indique le modificateur d'accès, qui peut être public, protected, private, ou le niveau d'accès par défaut (c'est-à-dire aucun modificateur d'accès explicitement spécifié).
  • type -- Indique le type de la variable.
  • variableName -- Indique le nom de la variable.

Contrairement aux variables locales, les variables membres ont leurs valeurs allouées lors de la création de l'objet. Même si elles ne sont pas initialisées, des valeurs par défaut leur sont attribuées. Par exemple, les variables de type int ont par défaut la valeur 0, et les variables de type boolean ont par défaut la valeur false.

Les variables membres peuvent être accessibles via un objet, ou via le nom de la classe (s'il s'agit de variables membres statiques). Si les variables membres ne sont pas explicitement initialisées, des valeurs par défaut leur sont attribuées. Vous pouvez initialiser les variables membres dans les constructeurs ou d'autres méthodes, ou y accéder via un objet ou le nom de la classe pour définir leurs valeurs.

Exemple

Dans l'exemple suivant, nous déclarons deux variables membres a et b, puis nous y accédons et les définissons. Notez que nous pouvons accéder aux variables membres via un objet, et nous pouvons également accéder aux variables membres statiques via le nom de la classe.

Exemple

public class ExampleTest {
      private int a; // Variable membre privée a
      public String b = "Hello"; // Variable membre publique b
     
      public static void main(String[] args) {
         ExampleTest obj = new ExampleTest(); // Créer un objet
         
          obj.a = 10; // Accéder à la variable membre a et définir sa valeur à 10
          System.out.println("a = " + obj.a);
         
          obj.b = "World"; // Accéder à la variable membre b et définir sa valeur à "World"
          System.out.println("b = " + obj.b);
      }
  }

L'exemple ci-dessus se compile et s'exécute avec le résultat suivant :

a = 10
b = World

Dans l'exemple suivant, nous déclarons deux variables membres name et salary, puis nous y accédons et les définissons.

Code du fichier Employee.java :

import java.io.*; public class Employee{ //Cette variable membre est visible pour les sous-classes public String name; //Variable privée, visible uniquement dans cette classe private double salary; //Affecter une valeur à name dans le constructeur public Employee (String empName){ name = empName; } //Définir la valeur de salary public void setSalary(double empSal){ salary = empSal; } //Afficher les informations public void printEmp(){ System.out.println("Nom :" + name ); System.out.println("Salaire :" + salary); } public static void main(String[] args){ Employee empOne = new Employee("EXAMPLE"); empOne.setSalary(1000.0); empOne.printEmp(); } }

L'exemple ci-dessus se compile et s'exécute avec le résultat suivant :

$ javac Employee.java 
$ java Employee
名字 : EXAMPLE
薪水 : 1000.0

Variables de classe (variables statiques)

Une variable statique en Java est une variable définie dans une classe. Elle est associée à la classe plutôt qu'aux instances. C'est-à-dire que, quel que soit le nombre d'instances de classe créées, il n'existe qu'une seule copie de la variable statique en mémoire, partagée par toutes les instances.

Les variables statiques sont créées lors du chargement de la classe et existent pendant toute l'exécution du programme.

Définition de méthode

La façon de définir une variable statique consiste à utiliser le mot-cléstaticpour modifier la variable, également communément appelée variable de classe.

Dans l'exemple suivant, nous définissons une variable statiquecount, avec une valeur initiale de 0 :

Exemple

public class MyClass {
    public static int count = 0;
    // Autres variables membres et méthodes
}

Méthode d'accès

Étant donné que les variables statiques sont associées à la classe, vous pouvez accéder aux variables statiques via le nom de la classe, et vous pouvez également accéder aux variables statiques via le nom de l'instance.

Exemple

MyClass.count = 10; // Accès via le nom de la classe
MyClass obj = new MyClass();
obj.count = 20; // Accès via le nom de l'instance

Cycle de vie

Le cycle de vie des variables statiques est aussi long que le cycle de vie du programme. C'est-à-dire qu'elles sont créées lorsque la classe est chargée et existent pendant toute l'exécution du programme, et ne sont pas détruites avant la fin du programme. Par conséquent, les variables statiques peuvent être utilisées pour stocker des données nécessaires à l'ensemble du programme, telles que des informations de configuration, des variables globales, etc.

Moment de l'initialisation

Les variables statiques sont initialisées lors du chargement de la classe, et leur ordre d'initialisation dépend de l'ordre de définition.

Si une variable statique dépend d'une autre variable statique, elle doit être définie après l'autre.

Exemple

public class MyClass {
    public static int count1 = 0;
    public static int count2 = count1 + 1;
    // Autres variables membres et méthodes
}

Dans l'exemple ci-dessus, count1 doit être initialisé avant count2 ; sinon, une erreur de compilation se produira.

La différence entre les constantes et les variables statiques

Les constantes sont également associées à la classe, mais ce sont des variables modifiées avec le mot-clé final, et une fois assignées, elles ne peuvent pas être modifiées. Contrairement aux variables statiques, la valeur d'une constante est déterminée au moment de la compilation, tandis que la valeur d'une variable statique peut être modifiée au moment de l'exécution. De plus, les constantes sont généralement utilisées pour stocker des valeurs fixes, telles que des constantes mathématiques, des informations de configuration, etc., tandis que les variables statiques sont généralement utilisées pour stocker des données mutables, telles que des compteurs, un état global, etc.

En résumé, les variables statiques sont des variables associées à la classe, avec unicité et partage. Elles peuvent être utilisées pour stocker des données nécessaires à l'ensemble du programme, mais il faut faire attention au moment de l'initialisation et à la différence avec les constantes.

Modificateurs d'accès pour les variables statiques

Le modificateur d'accès pour les variables statiques peut être public, protected, private, ou le modificateur d'accès par défaut (c'est-à-dire ne pas écrire de modificateur d'accès).

Il convient de noter que l'autorisation d'accès des variables statiques est différente de celle des variables d'instance, car les variables statiques sont associées à la classe et ne dépendent d'aucune instance.

Sécurité des threads des variables statiques

Les variables statiques en Java appartiennent à la classe, et non aux instances d'objet. Par conséquent, lorsque plusieurs threads accèdent simultanément à une classe contenant des variables statiques, la sécurité des threads doit être prise en compte.

Les variables statiques n'ont qu'une seule copie en mémoire, partagée par toutes les instances. Par conséquent, si un thread modifie la valeur d'une variable statique, les autres threads verront également la valeur modifiée lorsqu'ils accéderont à cette variable statique. Cela peut entraîner des problèmes de concurrence, car plusieurs threads peuvent modifier la variable statique en même temps, ce qui conduit à des résultats incertains ou à des problèmes de cohérence des données.

Pour garantir la sûreté des threads pour les variables statiques, des mesures de synchronisation appropriées sont nécessaires, telles que des mécanismes de synchronisation, des classes atomiques ou le mot-clé volatile, afin que les valeurs des variables statiques puissent être correctement lues et modifiées dans un environnement multi-thread.

Conventions de nommage des variables statiques

La convention de nommage des variables statiques (également appelées variables de classe) suit généralement camelCase, et utilise généralement des lettres entièrement majuscules avec des traits de soulignement entre les mots, et doit être explicitement marquée avec le mot-clé static.

  • Utiliser camelCase :Le nommage des variables statiques doit utiliser camelCase, c'est-à-dire que la première lettre est en minuscule et la première lettre de chaque mot suivant est en majuscule. Par exemple :myStaticVariable。

  • Toutes les lettres en majuscules :Les variables statiques utilisent généralement des lettres entièrement majuscules avec des traits de soulignement entre les mots. C'est ce qu'on appelle « Upper Snake Case ». Par exemple :MY_STATIC_VARIABLE。

  • Descriptif :Les noms de variables doivent être significatifs et exprimer clairement le but de la variable. Évitez d'utiliser des caractères uniques ou des abréviations sans signification claire.

  • Éviter d'utiliser des abréviations :Essayez d'éviter d'utiliser des abréviations pour améliorer la lisibilité du code. Si l'utilisation d'abréviations est nécessaire, assurez-vous qu'elles sont largement comprises et expliquez-les dans les commentaires.

Exemple

public class MyClass {
    // Utiliser camelCase
    public static int myStaticVariable;

    // Utiliser Upper Snake Case
    public static final int MAX_SIZE = 100;

    // Éviter d'utiliser des abréviations
    public static final String employeeName;

    // Noms de variables descriptifs
    public static double defaultInterestRate;
}

Scénarios d'utilisation des variables statiques

Les variables statiques sont couramment utilisées dans les scénarios suivants :

  • Stockage d'un état global ou d'informations de configuration
  • Compteurs ou informations statistiques
  • Mise en cache de données ou de ressources partagées
  • Constantes ou méthodes dans les classes utilitaires
  • Variables d'instance dans le patron singleton

Exemple

L'exemple suivant définit une classe AppConfig qui contient trois variables statiques : APP_NAME, APP_VERSION et DATABASE_URL, utilisées pour stocker le nom de l'application, la version et l'URL de connexion à la base de données. Ces variables sont toutes déclarées comme final, ce qui indique qu'il s'agit de constantes immuables.

Dans la méthode main(), nous affichons les valeurs de ces variables statiques.

Code du fichier AppConfig.java:

public class AppConfig { public static final String APP_NAME = "MyApp"; public static final String APP_VERSION = "1.0.0"; public static final String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb"; public static void main(args[] System) { System.out.println("Nom de l'application: " + AppConfig.APP_NAME); System.out.println("Version de l'application: " + AppConfig.APP_VERSION); System.out.println("URL de la base de données: " + AppConfig.DATABASE_URL); } }

L'exemple ci-dessus se compile et s'exécute avec le résultat suivant :

Application name: MyApp
Application version: 1.0.0
Database URL: jdbc:mysql://localhost:3306/mydb

On peut voir que les informations de configuration globales stockées dans ces variables statiques peuvent être utilisées dans tout le programme et ne seront pas modifiées. Cet exemple illustre une autre application courante des variables statiques, grâce à laquelle nous pouvons facilement stocker des informations de configuration globales, ou implémenter d'autres données qui doivent être partagées globalement.

L'exemple suivant définit une classe Counter qui contient une variable statique count, utilisée pour enregistrer combien d'objets Counter ont été créés.

Chaque fois qu'un nouvel objet est créé, le constructeur incrémente le compteur de un. La méthode statique getCount() est utilisée pour obtenir la valeur actuelle du compteur.

Dans la méthode main(), nous créons trois objets Counter et affichons la valeur du compteur.

Code du fichier Counter.java :

public class Counter { private static int count = 0; public Counter() { count++; } public static int getCount() { return count; } public static void main(String[] args) { Counter c1 = new Counter(); Counter c2 = new Counter(); Counter c3 = new Counter(); System.out.println("Nombre d'objets créés jusqu'à présent :" + Counter.getCount()); } }

L'exemple ci-dessus se compile et s'exécute avec le résultat suivant :

目前为止创建的对象数: 3

On peut voir que le compteur enregistre que trois objets ont été créés. Cet exemple montre une application simple des variables statiques, grâce auxquelles nous pouvons facilement compter le nombre de créations d'objets, ou enregistrer d'autres données qui doivent être partagées globalement.

Dans ce chapitre, nous avons découvert les types de variables Java. Dans le chapitre suivant, nous présenterons l'utilisation des modificateurs Java.

Autres extensions