Qu'est-ce que les variables Java?
Les variables sont les unités de base utilisées pour stocker toute information en Java. Le nom de 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 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 attribuées à différentes variables qui seront stockées dans leurs emplacements de mémoire respectifs, donc une variable n'est rien d'autre que le nom d'un emplacement de mémoire. Le stockage de valeurs dans des variables est plus efficace que la répétition des valeurs partout dans le code. En outre, cela aide en cas de modification de la valeur requise, car il suffit de la modifier à un endroit de la déclaration de variable plutôt que de devoir la modifier à plusieurs emplacements.
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 la valeur qu'elle peut contenir. Divers 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 variable
1 -> valeur variable
Le diagramme suivant donne la représentation picturale du même:
Initialisation des variables
L'attribution d'une valeur par défaut à la variable s'appelle l'initialisation de cette variable. Une variable peut être initialisée à la fois pendant la déclaration et au cours des étapes ultérieures du programme selon les besoins.
Exemples:
Voici quelques-unes des valeurs que nous pouvons attribuer à une variable par rapport à son type de données particulier
1) int i; i = 10;
2) ville de chaîne; ville = "Bangalore";
3) char a; a = 'H';
4) flotteur dec; déc = 3, 5;
5) Val booléen; 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 ou 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 fermé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:
a) Dans l'exemple suivant, nous considérons «num» et «name» comme variables locales
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();
)
)
Production:
Le nom du patient est: Harish
Numéro du patient: 1200
Le nom du patient est: Sudha
Numéro du patient: 1201
Le nom du médecin est: Vijay
L'identifiant du médecin est: 12000
Le nom du médecin est: Suma
Le numéro d'identification 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, à savoir Patient et DoctorDetails, peuvent être utilisés pour attribuer un nombre quelconque de valeurs différentes.
Exemple:
b) Les mêmes variables locales "num" et "name" seront invalides si nous essayons d'afficher leur valeur en dehors de leur méthode
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
)
)
Production:
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: variable num
emplacement: classe PatientDetails
1 erreur
2) Variables d'instance
- Les variables d'instance sont celles qui sont déclarées dans une classe et non dans une méthode.
- Ils sont créés lorsqu'un objet est créé 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.
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);
)
)
Production:
Valeurs pour le premier objet:
44
77
88
Valeurs pour le deuxième objet:
77
55
74
3) Variables statiques
- Les variables statiques sont déclarées au début du programme précédées du mot-clé static.
- Comme les variables d'instance, l'initialisation des variables statiques n'est pas obligatoire et leur valeur par défaut est 0.
- Il ne peut y avoir qu'un seul nom de variable statique qui sera créé au démarrage du programme et perdu une fois l'exécution terminée.
- La mémoire de ces variables n'est allouée qu'une seule fois au moment du chargement de la classe et peut être partagée par plusieurs objets.
- Lorsque les objets sont différents, les modifications apportées à la valeur de la variable statique dans l'un des objets seront reflétées dans toutes les variables d'instance contrairement aux où les valeurs déclarées dans un objet ne seront pas reflétées dans d'autres.
Exemple:
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);
)
)
Production:
Le rollno de Lilly est: 101 et le numéro de classe est: 3
Conclusion - Variables en Java
Les variables forment la partie élémentaire d'un programme Java. Ils pointent vers un emplacement mémoire particulier lorsqu'ils sont créés et le même est libéré lorsque l'objet n'est plus référencé. Cette mémoire libérée sera balayée lors de la collecte des ordures. Ce processus peut également être considéré comme le cycle de vie d'une variable.
Articles recommandés
Ceci est un guide des variables en Java. Ici, nous discutons des types avec l'initialisation et la déclaration des variables. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Boucle en Java
- Motifs d'étoiles en Java
- Meilleur IDE Java
- Meilleurs compilateurs Java
- Comment initialiser des variables en C #?
- Variables en JavaScript
- Mot-clé statique en C