Variables Java

Dans cet article, nous allons expliquer à tous les apprenants Java ce que sont les variables Java et comment les utiliser.

Qu'est-ce qu'une variable Java

Une variable en Java peut être considérée comme une boîte. Cette "boîte" a une certaine taille : la mémoire qui lui est allouée. La quantité de mémoire allouée dépend du type de variable, mais nous en reparlerons un peu plus tard. Dans le même temps, la taille de la boîte elle-même ne peut pas être modifiée après sa création, mais le contenu peut. La case peut être vide. Vous pouvez "y insérer" une valeur, puis extraire et mettre une autre valeur. Ainsi, une variable est un champ qui stocke des valeurs de données lors de l'exécution d'un programme Java. Cette box a des caractéristiques importantes :

il peut toujours contenir une seule valeur (ou peut être vide, auquel cas il contiendra la valeur par défaut),
Il a un type de données. Sa taille dépend du type de données, ainsi que de la zone de mémoire particulière à laquelle la place lui est attribuée (où elle se trouve).

Comment déclarer des variables

Pour déclarer des variables en Java, vous devez spécifier son type et son nom. Voici un exemple de déclaration de trois variables :

int myInt;
String s;
Object variableName;

Ici , int , String et Object sont le type de données et myInt , s , variableName sont des noms de variables. Le type de données doit être choisi en fonction des besoins du programme, et il est préférable de choisir un nom pour qu'il soit clair de quoi il s'agit. Bien sûr, pour les débutants, ce n'est pas si strict, mais dans les grands projets, les noms de variables comme 's' peuvent nuire à la lisibilité du code. Il est donc préférable de s'habituer à nommer les variables d'une manière qui indique clairement à quoi elles servent dès le début. Dans la limite du raisonnable, bien sûr.

Comment initialiser les variables

Lorsque vous déclarez une variable, vous lui allouez de la mémoire. L'initialisation signifie que vous "mettez" une certaine valeur dans la "boîte". Cela peut être fait immédiatement lors de la déclaration de la variable ou ultérieurement. De plus, la valeur d'une variable peut changer pendant l'exécution du programme. Exemple:

public class VariableTest {
    public static void main(String[] args) {
        int myInt = 5;
        String s;
        s = "init";
        System.out.println(s);
        s = s+5;
        System.out.println(s);
    }
}

Ici, nous avons déclaré et initialisé la variable myInt sur une ligne, lui allouant immédiatement de la mémoire (32 bits pour chaque nombre int), lui avons donné un nom, puis avons placé la valeur 5 dans la mémoire allouée. Ensuite, nous avons déclaré que nous allouions de l'espace mémoire pour la chaîne s , et déjà une commande distincte y a mis la valeur "init". Après cela, nous avons imprimé la chaîne et modifié la valeur de la variable s . Dans ce programme, nous avons imprimé les lignes, et si vous l'exécutez, vous verrez le résultat suivant :

init init5

Types de données des variables en Java: primitifs et non primitifs

Les types de données des variables en Java sont divisés en deux groupes :

Les types de données primitifs incluent byte , short , int , long , float , double , boolean et char
Types de données non primitifs tels que String , Arrays et Classes

Voici un exemple de travail avec des variables :

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point number
       char myLetter = 'a';         // character
       boolean myBool = true;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

int , char , boolean et float sont des primitives. String est non primitif. Qu'en est-il de la variable myStudent ? Il s'agit d'un objet de la classe créée par l'utilisateur Student . Il a été créé simplement pour illustrer le travail avec des variables non primitives. Ils sont majoritaires en Java, puisque presque tout dans ce langage de programmation est un objet. Pour la compréhension, voici le code de la classe Student :

import java.util.Date;

public class Student {
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

Types de variables en Java: local, instance et statique

Il existe trois types de variables différents en Java, nous les avons répertoriés comme suit :

Variables locales
Variables d'instance
Variables statiques

Variables locales

Une variable déclarée dans le corps de la méthode est appelée une variable locale. De plus, les variables locales sont déclarées à l'intérieur des constructeurs et des blocs. Vous pouvez utiliser des variables locales uniquement dans cette méthode, ce constructeur ou ce bloc où elles ont été créées et les autres méthodes de la classe ne savent même pas que la variable existe. Ainsi, les variables locales sont créées lorsque la méthode, le constructeur ou le bloc est entré et la variable est détruite une fois que la méthode, le constructeur ou le bloc ne fonctionne pas. Une variable locale ne peut pas être définie avec le mot-clé static . Encore plus : vous ne pouvez pas utiliser de modificateurs d'accès pour les variables locales. Voici un exemple:

public class VariableTest {
   public static void main(String[] args) {
       System.out.println(myMethod("C plus "));
   }
           private static String myMethod(String myString) {
       String myOtherString = "plus";
       return myString + myOtherString;
   }
}

Ici myOtherString est une variable locale. Vous ne pouvez pas l'utiliser à partir de l'autre méthode, mais myMethod . Les variables locales ne peuvent pas avoir de valeurs par défaut. Si au moins une variable locale n'est pas initialisée dans le programme, le programme ne fonctionnera pas correctement. Apportons une petite modification à l'un des exemples précédents et "oublions" d'initialiser la variable myBool :

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point
       char myLetter = 'a';         // character
       boolean myBool;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

Si nous essayons d'exécuter le programme, il renverra une erreur :

Erreur :(10, 50) java : la variable myBool n'a peut-être pas été initialisée

Variables d'instance

Une variable déclarée à l'intérieur de la classe mais en dehors du corps de toute méthode, constructeur ou bloc est appelée une variable d'instance. Les variables d'instance sont créées lorsqu'un objet est créé à l'aide du nouveau mot-clé. Il est détruit lorsque l'objet est détruit. Il ne peut pas être déclaré comme statique, mais vous pouvez utiliser des modificateurs d'accès pour les variables d'instance. Les variables d'instance sont visibles pour toutes les méthodes, constructeurs et blocs de la classe. Généralement, les variables d'instance sont privées, mais vous pouvez modifier la visibilité des sous-classes. Contrairement aux variables locales, les variables d'instance ont des valeurs par défaut. Pour tous les types primitifs numériques, la valeur par défaut est 0, pour les booléens c'est faux et pour les références d'objet c'est nul. Les valeurs peuvent être affectées lors de la déclaration ou dans le constructeur. Voici un exemple:

//instance variable example
public class Employee {

   // here we have a public instance variable. It is visible for this class and child classes
   public String name;

   //this instance variable is private so it’s visible for the Employee class only. You can use setters and getters to get it
   private double salary;

   public Employee (String empName) {
       name = empName;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public double getSalary() {
       return salary;
   }

   public void setSalary(double employeeSalary) {
       salary = employeeSalary;
   }

   public static void main(String args[]) {
       Employee employee = new Employee("Johnny");
       employee.setSalary(1500);
       System.out.println("name = " + employee.getName());
       System.out.println("salary = " + employee.getSalary());
   }
}

Variables statiques

Une variable déclarée statique est appelée une variable statique. Java vous propose de déclarer de telles variables en dehors d'une méthode, d'un constructeur ou d'un bloc. Il ne peut pas être local, ils appartiennent à la classe, pas aux instances. Cela signifie qu'une seule copie d'une variable statique une fois créée et partagée entre toutes les instances de la classe. L'allocation de mémoire pour les variables statiques ne se produit qu'une seule fois lorsque la classe est chargée dans la mémoire. Ils peuvent avoir n'importe quelle visibilité, mais ils sont généralement déclarés publics. Ils ont également des valeurs par défaut telles que des variables d'instance.

public class Box
{
   public void add(int data)
   {
       Storage.sum = Storage.sum + data;
       Storage.count++;
   }

   public void remove(int data)
   {
       Storage.sum = Storage.sum - data;
       Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

Dans l'exemple ci-dessus, nous avons créé une classe de stockage distincte , y avons déplacé les variables count et sum et les avons déclarées statiques. Les variables statiques publiques sont accessibles à partir de n'importe quelle méthode de programme (et pas seulement à partir d'une méthode). Pour renforcer ce que vous avez appris, nous vous suggérons de regarder une leçon vidéo de notre cours Java