Variables en Java

Les variables sont les unités de base utilisées pour stocker toute information en Java. Le nom de la variable est le nom attribué à ces unités. Un code Java peut avoir besoin d'informations sous la forme d'une valeur numérique ou de chaîne. Le même ensemble de valeurs peut être requis à plusieurs étapes d’un code. C'est là qu'une variable entre en scène.

Toutes ces valeurs requises peuvent être affectées à différentes variables qui seront stockées dans leurs emplacements mémoire respectifs ; donc une variable n’est rien d’autre que le nom d’un emplacement mémoire. Stocker des valeurs dans des variables est plus efficace que de répéter les valeurs partout dans le code. En outre, cela est utile lorsqu'il y a un changement dans la valeur requise, car il suffit de la changer à un endroit de la déclaration de variable plutôt que de devoir la modifier à plusieurs endroits.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Déclaration des variables

Une variable ne peut pas être utilisée tant qu'elle n'est pas déclarée, et le type de données que nous attribuons lors de la déclaration définit le type de valeur qu'elle peut contenir. Différents types de données tels que int, float, string, char, Boolean, long, double peuvent être attribués à une variable.

La syntaxe générale pour déclarer une variable en Java est la suivante :

Ex: int a = 1;

Où,

• int – type de données
• a – nom de la variable
• 1 – valeur variable

Le schéma suivant en donne la représentation picturale :

Initialisation des variables

L'attribution d'une valeur par défaut à la variable est appelée l'initialisation de cette variable. Une variable peut être initialisée à la fois lors de la déclaration et lors des étapes ultérieures du programme, selon les besoins. Exemples : Voici quelques-unes des valeurs que nous pouvons attribuer à une variable en fonction de son type de données particulier :

•  int je ; je=10;
•  ville de chaîne ; ville=”Bangalore”;
•  caractère a ; a='H';
•  déclin flottant ; décembre=3.5;
•  Valeur booléenne ; val=true;

Types de variables

Il existe 3 types de variables en Java :

• Variable locale
• Variable d'instance
• Variable statique

1. Variables locales

• Ce sont des variables déclarées dans une méthode, un bloc ou un constructeur particulier dans lequel elles se trouvent.
• Leur valeur de variable, qui est stockée lors de la déclaration, n'est valide que dans le cadre de cette méthode et est perdue lorsque la méthode est quittée.
• Une variable locale avec le même nom de variable peut être déclarée dans plusieurs méthodes ou blocs sans aucun conflit.

Exemple : Dans l'exemple suivant, nous considérons « num » et « name » comme variables locales. Code :

public class PatientDetails{
public void Patient()
{
// local variable num
//local variable name
int num = 1200;
string name = "Harish";
id = id + 1;
System.out.println("Patient Name is: " + name + " Patient Number is: " + num);
name = "Sudha";
System.out.println("Patient Name is: " + name + " Patient Number is: " + num);
}
public void DoctorDetails()
{
int num = 12000;
string name = "Vijay";
num = num +1;
System.out.println("Doctor Name is: " + name + " Doctor ID is: " + num);
name = "Suma";
System.out.println("Doctor Name is: " + name + " Doctor ID is: " + num);
}
public static void main(String args[])
{
PatientDetails pat = new PatientDetails();
pat. Patient();
pat.DoctorDetails();
}
}

Sortie :

Le nom du patient est : Harish
Le numéro de patient est : 1200
Le nom du patient est : Sudha
Le numéro du patient est : 1201
Le nom du docteur est : Vijay
L'identifiant du médecin est : 12000
Le nom du docteur est : Suma
L'identifiant du médecin est : 12001

Cela montre que les mêmes noms de variables locales « num » et « name », lorsqu'ils sont déclarés dans deux méthodes différentes, c'est-à-dire Patient et DoctorDetails, peuvent être utilisés pour attribuer n'importe quel nombre de valeurs différentes.

Exemple :

Les mêmes variables locales « num » et « name » seront invalides si nous essayons d'afficher leur valeur en dehors de leur méthode.

Code :

public class PatientDetails{
public void Patient()
{
// local variable num
//local variable name
int id = 1200;
}
public static void main(String args[])
{
System.out.println("Patient Number is: " + num);
//printing local variable outside it's method
}
}

Sortie :

Erreur de compilation dans le code java :-
prog.java:12 : erreur : impossible de trouver le symbole
System.out.println(« Le numéro du patient est : » + num);
^
symbole : numéro variable
emplacement : classe PatientDetails
1 erreur

2. Variables d'instance

• Les variables d'instance sont celles qui sont déclarées à l'intérieur d'une classe et non dans une méthode.
• Ils sont créés lors de la création d'un objet, et leur valeur est perdue lorsque l'objet est détruit.
• L'initialisation de ces variables n'est pas obligatoire, et par défaut, la valeur est prise à zéro.
• Ce sont des variables non statiques, ce qui signifie que la mémoire de la variable sera allouée chaque fois qu'un nouvel objet est créé.

Exemple :

Ici a, b, c sont les variables d'instance qui sont déclarées dans deux instances différentes par deux objets différents.

Code :

import java.io.*;
class Marks {
// a, b, c are instance variables
// a, b, c variables are being declared inside a class and not function
int a;
int b;
int c;
}
class MarksDemo {
public static void main(String args[])
{
// first object declaration
Alpha alp1 = new Alpha();
alp1 .a= 44;
alp1 .b= 77;
alp1 .c= 88;
// second object declaration
Alpha alp2 = new Alpha();
alp2 .a= 77;
alp2 .b= 55;
alp2 .c= 74;
// displaying variable values for first object
System.out.println("Values for first object:");
System.out.println(alp1.a);
System.out.println(alp1.b);
System.out.println(alp1.c);
// displaying variable values for second object
System.out.println("Values for second object:");
System.out.println(alp2.a);
System.out.println(alp2.b);
System.out.println(alp2.c);
}
}

Sortie :

Valeurs du premier objet :
44
77
88
Valeurs pour le deuxième objet :
77
55
74

3. Static Variables

• Static variables are declared at the beginning of the program, preceded by the static keyword.
• Like instance variables, the initialization of static variables is not mandatory, and their default value is 0.
• Only one static variable name will be created when the program is started and lost when execution has ended.
• The memory for these variables is allocated only once at the time of loading the class and can be shared by multiple objects.
• When the objects are different, the changes made in the value of the static variable in one of the objects will be reflected in all unlike instance variables where the values declared in one object will not be reflected in others.

Example:

Code:

import java.io.*;
class Students {
//static variable rollno
public static double rollno;
public static String name = "Lilly";
public static classnum;
}
public class StudentDetails {
public static void main(String args[])
}
{
// no need of object to access static variables
Students .rollno= 101;
Students.classnum=3;
System.out.println(Students .name + "'s rollno is:" + Students .rollno + "and class number is:" + Students.classnum);
}
}

Output:

Lilly’s rollno is 101, and the class number is: 3

Conclusion – Variables in Java

Variables form the elemental part of a Java program. They point to a particular memory location when they are created, and the same is released when the object is not referenced anymore. This memory which is released, will be swept away when garbage collection takes place. This process can also be considered as the life cycle of a variable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!