Les variables dans Java

Une variable est le nom donné à un emplacement de mémoire. C’est l’unité de base de stockage dans un programme.

La valeur stockée dans une variable peut être modifiée pendant l’exécution du programme.

Une variable est seulement un nom donné à un emplacement de mémoire, toutes les opérations effectuées sur la variable affectent cet emplacement de mémoire.

En Java, toutes les variables doivent être déclarées avant utilisation.

Comment déclarer des variables?

Nous pouvons déclarer des variables en java comme suit:

type de données: Type de données pouvant être stockées dans cette variable.
nom_variable: Nom donné à la variable.
valeur: C’est la valeur initiale stockée dans la variable.

Exemples:

float simpleInterest; // Déclaration d'une variable float
int temps = 10, vitesse = 20; // Déclaration et initialisation des variables entières
char var = 'h'; // Déclaration et initialisation d'une variable de type caractère

Il existe trois types de variables en Java:

• Variables locales
• Variables d’instance
• Variables statiques

Voyons maintenant chacune de ces variables en détail.

Variables locales: une variable définie dans un bloc, une méthode ou un constructeur est appelée variable locale.

• Ces variables sont créées lorsque le bloc est exécute ou que la fonction est appelée et détruites après la sortie du bloc ou lorsque l’appel est renvoyé de la fonction.
• La portée de ces variables n’existe que dans le bloc dans lequel la variable est déclarée. c’est-à-dire que nous ne pouvons accéder à ces variables que dans ce bloc.
• L’initialisation de la variable locale est obligatoire.

Exemple de programme 1:

public class StudentDetails 
{ 
public void StudentAge() 
{ //local variable age 
int age = 0; 
age = age + 5; 
System.out.println("L'âge de l'étudiant est : " + age); 
} 

public static void main(String args[]) 
{ 
StudentDetails obj = new StudentDetails(); 
obj.StudentAge(); 
} 
}

Sortie:

L'âge de l'étudiant est: 5

Dans le programme ci-dessus, la variable age est une variable locale de la fonction StudentAge (). Si nous utilisons la variable age en dehors de la fonction StudentAge (), le compilateur générera une erreur, comme indiqué dans le programme ci-dessous.

Exemple de programme 2:

public Class StudentDetails
{
     public void StudentAge ()
     {// variable d'âge locale
         int age = 0;
         age = age + 5;
     }
  
     public static void main (String args [])
     {
         // en utilisant la variable locale age en dehors de sa portée
         System.out.println ("L'âge de l'élève est:" + age);
     }
}

Sortie:

erreur: impossible de trouver le symbole
  "+ age);

Variables d’instance: Les variables d’instance sont des variables non statiques et sont déclarées dans une classe en dehors de toute méthode, constructeur ou bloc.

• Lorsque des variables d’instance sont déclarées dans une classe, ces variables sont créées lorsqu’un objet de la classe est créé et détruites lors de la destruction de l’objet.
• Contrairement aux variables locales, nous pouvons utiliser des spécificateurs d’accès pour les variables d’instance. Si nous ne spécifions aucun spécificateur d’accès, le spécificateur d’accès par défaut sera utilisé.
• L’initialisation de la variable d’instance n’est pas obligatoire. Sa valeur par défaut est 0
  La variable d’instance n’est accessible qu’en créant des objets.

Exemple de programme:

importer java.io. *;
class Mark
{
    // Ces variables sont des variables d'instance.
    // Ces variables sont dans une classe et ne sont dans aucune fonction
    int engMarks;
    int mathsMarks;
    int phyMarks;
}
  
class MarksDemo
{
    public static void main (String args [])
    {// premier objet
        Mark obj1 = new Mark ();
        obj1.engMarks = 50;
        obj1.mathsMarks = 80;
        obj1.phyMarks = 90;
  
        // deuxième objet
        Mark obj2 = new Mark ();
        obj2.engMarks = 80;
        obj2.mathsMarks = 60;
        obj2.phyMarks = 85;
  
        // affichage des marques pour le premier objet
        System.out.println ("Marques pour le premier objet:");
        System.out.println (obj1.engMarks);
        System.out.println (obj1.mathsMarks);
        System.out.println (obj1.phyMarks);
      
        // affichage des repères pour le deuxième objet
        System.out.println ("Marques pour le second objet:");
        System.out.println (obj2.engMarks);
        System.out.println (obj2.mathsMarks);
        System.out.println (obj2.phyMarks);
    }
}

Sortie:

Marques pour le premier objet:
50
80
90
Marques pour le deuxième objet:
80
60
85

Comme vous pouvez le voir dans le programme ci-dessus, les variables, engMarks, mathsMarks, variables d’instance phyMarksare. Si nous avons plusieurs objets, comme dans le programme ci-dessus, chaque objet aura ses propres copies de variables d’instance. La sortie ci-dessus montre clairement que chaque objet aura sa propre copie de variable d’instance.

Variables statiques: Les variables statiques sont également appelées variables de classe.

• Ces variables sont déclarées de la même façon que les variables d’instance. La différence est que les variables statiques sont déclarées à l’aide du mot clé static dans une classe en dehors de tout constructeur ou bloc de méthode.
• Contrairement aux variables d’instance, nous ne pouvons avoir qu’une seule copie d’une variable statique par classe, quel que soit le nombre d’objets créés.
• Les variables statiques sont créées au début de l’exécution du programme et détruites automatiquement à la fin de l’exécution.
• L’initialisation de la variable statique n’est pas obligatoire. Sa valeur par défaut est 0
• Si nous accédons à la variable statique comme une variable d’instance (à travers un objet), le compilateur affichera le message d’avertissement et ne modifiera pas le programme. Le compilateur remplacera automatiquement le nom de l’objet par le nom de la classe.
• Si nous accédons à la variable statique sans nom de classe, le compilateur ajoutera automatiquement le nom de la classe.

Pour accéder aux variables statiques, nous n’avons besoin de créer aucun objet de cette classe, nous pouvons simplement accéder à la variable de la manière suivante:

nom_classe.nom_variable;

importer java.io. *;
class Emp {
  
   // salaire est une variable statique
   public static double salaire ;
   public static String name = "Harsh";
}
  
classe publique EmpDemo
{
     public static void main (String args []) {
        
      // accès à une variable statique sans objet
      Emp.salary = 1000;
      System.out.println (salaire moyen de Emp.name + ": + Emp.salary);
   }
      
}

sortie:

Salaire moyen de Harsh: 1000,0

Variable d’instance Vs Variable statique

Chaque objet aura sa propre copie de variable d’instance alors que Nous ne pouvons avoir qu’une copie d’une variable statique par classe, quel que soit le nombre d’objets que nous créons.

Les modifications apportées dans une variable d’instance à l’aide d’un objet ne seront pas répercutées dans la mesure où chaque objet possède sa propre copie de la variable d’instance. En cas de statique, les modifications seront reflétées dans d’autres objets car les variables statiques sont communes à tous les objets d’une classe.

Nous pouvons accéder aux variables d’instance via des références d’objet et les variables statiques sont accessibles directement à l’aide du nom de la classe.

Syntaxe pour les variables statiques et d’instance:

Class exemple
    {
        static int a; // variable statique
        int b; // variable d'instance
    }