Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Les variables en Java

Une variable nous fournit un stockage nommé que nos programmes peuvent manipuler. Chaque variable en Java a un type spécifique, qui détermine la taille et la disposition de la mémoire de la variable; la plage de valeurs pouvant être stockées dans cette mémoire; et l'ensemble des opérations pouvant être appliquées à la variable.

Vous devez déclarer toutes les variables avant de pouvoir les utiliser.

Syntaxe :
                                TypeDonnees variable[ = value][, variable [ = value] ...];
                            

Ici, "TypeDonnees" est l'un des types de données Java et "variable" est le nom de la variable. Pour déclarer plusieurs variables du type spécifié, vous pouvez utiliser une liste séparée par des virgules.

Exemple 1 :
                                int a, b=2;
                                float c=1.05f, d
                                char a = 'a';
                            

Ce cours explique divers types de variables disponibles en langage Java. Il existe trois types de variables en Java :

  •  Variables locales
  •  Variables d'instance
  •  Variables de classe/statiques

Variables locales

  •   Les variables locales sont déclarées dans des méthodes, des constructeurs ou des blocs.
  •   Les variables locales sont créées lorsque la méthode, le constructeur ou le bloc sont entrés (appelés) et la variable est détruite une fois qu'elle quitte la méthode, le constructeur ou le bloc.
  •   Les modificateurs d'accès ne peuvent pas être utilisés pour les variables locales.
  •   Les variables locales ne sont visibles que dans la méthode, le constructeur ou le bloc.
  •   Les variables locales sont implémentées au niveau de la pile en interne.
  •   Il n'y a pas de valeur par défaut pour les variables locales. Par conséquent, les variables locales doivent être déclarées et une valeur initiale doit être attribuée avant la première utilisation.
Exemple 2 :

Ici, "val" est une variable locale. Ceci est défini dans la méthode "afficher()" et sa portée est limitée à cette méthode.

                                public class Test{
                                    public void afficher(){
                                        int val =3;
                                        System.out.println("val : " + val);
                                    }
                                    public static void main(String args[]){
                                        Test T= new Test();
                                        T.afficher();
                                    }
                                }
                            
val : 3
Exemple 3 :

L'exemple suivant utilise "val" sans l'initialiser, ce qui donnerait une erreur au moment de la compilation.

                                public class Test{
                                    public void afficher(){
                                        int val;
                                        System.out.println("val : " + val);
                                    }
                                    public static void main(String args[]){
                                        Test T= new Test();
                                        T.afficher();
                                    }
                                }
                            
Test.java:4: error: variable val might not have been initialized
System.out.println("val : " + val);
^
1 error

Variables d'instances

  •   Les variables d'instance sont déclarées dans une classe, mais en dehors d'une méthode, d'un constructeur ou de tout bloc.
  •   Lorsqu'un espace est alloué pour un objet dans la mémoire, un emplacement pour chaque valeur de variable d'instance est créé.
  •   Les variables d'instance sont créées lors de la création d'un objet à l'aide du mot clé "new" et détruites lors de la destruction de l'objet.
  •   Les variables d'instance contiennent des valeurs qui doivent être référencées par plusieurs méthodes, constructeurs ou blocs, ou par des parties essentielles de l'état d'un objet qui doivent être présentes dans toute la classe.
  •   Les variables d'instance peuvent être déclarées au niveau classe avant ou après utilisation.
  •   Des modificateurs d'accès peuvent être donnés pour les variables d'instance.
  •   Les variables d'instance sont visibles pour toutes les méthodes, les constructeurs et les blocs de la classe. Normalement, il est recommandé de rendre ces variables privées (niveau d'accès). Cependant, la visibilité des sous-classes peut être donnée pour ces variables grâce à l'utilisation de modificateurs d'accès.
  •   Les variables d'instance ont des valeurs par défaut. Pour les nombres, la valeur par défaut est 0, pour Booleans, la valeur est false et pour les références d'objet, la valeur est null. Les valeurs peuvent être affectées lors de la déclaration ou dans le constructeur.
  •   Les variables d'instance sont accessibles directement en appelant le nom de la variable dans la classe. Toutefois, dans les méthodes statiques (lorsque les variables d'instance ont une accessibilité donnée), elles doivent être appelées à l'aide du nom complet. ObjetReference.NomVariable.
Exemple 4 :
                                public class Personne{

                                    private String nom;
                                    private int age;

                                    public Personne(String nom, int age){
                                        this.nom=nom;
                                        this.age=age;
                                    }
                                    public void afficher(){
                                        System.out.println("Nom : " + nom + " - age : " + age);
                                    }

                                    // méthode principale (main)
                                    public static void main(String args[]){
                                        Personne p= new Personne("Mostafa", 32);
                                        p.afficher();
                                    }
                                }
                            
Nom : Mostafa - age : 32

Variables de classe/statiques

  •   Les variables de classe, également appelées variables statiques, sont déclarées avec le mot clé static dans une classe, mais en dehors d'une méthode, d'un constructeur ou d'un bloc.
  •   Il n'y aurait qu'une copie de chaque variable de classe par classe, quel que soit le nombre d'objets créés à partir de celle-ci.
  •   Les variables statiques sont rarement utilisées autrement que d'être déclarées comme constantes. Les constantes sont des variables déclarées comme public/private, final, et static. Les variables constantes ne changent jamais de leur valeur initiale.
  •   Les variables statiques sont stockées dans la mémoire statique. Il est rare d'utiliser des variables statiques autres que déclarées final et utilisées comme constantes public ou private.
  •   Les variables statiques sont créées au démarrage du programme et détruites à son arrêt.
  •   La visibilité est similaire aux variables d'instance. Cependant, la plupart des variables statiques sont déclarées publiques car elles doivent être disponibles pour les utilisateurs de la classe.
  •   Les valeurs par défaut sont identiques à celles des variables d'instance. Pour les nombres, la valeur par défaut est 0; pour les booléens, c'est faux; et pour les références d'objet, il est nul. Les valeurs peuvent être affectées lors de la déclaration ou dans le constructeur. De plus, les valeurs peuvent être affectées dans des blocs d'initialisation statiques spéciaux.
  •   On peut accéder aux variables statiques en appelant avec le nom de classe NomClass.NomVariable.
  •   Lors de la déclaration de variables de classe en tant que public static final, les noms de variables (constantes) sont tous en majuscules. Si les variables statiques ne sont pas publiques et finales, la syntaxe de dénomination est identique à celle des variables d'instance et locales.
Exemple 5 :
                                public class Personne {

                                    private String nom;
                                    private int age;
                                    
                                    private static double salaire;
                                    
                                    public static final String DEPARTMENT = "SI";
                                    
                                    public Personne(String nom, int age) {
                                        this.nom = nom;
                                        this.age = age;
                                    }
                                    
                                    // méthode principale (main)
                                    public static void main(String args[]) {
                                        // ou Personne.salaire
                                        salaire = 1000;
                                    
                                        // ou Personne.DEPARTMENT
                                        System.out.println("Département " + DEPARTMENT + " Salaire : " + salaire);
                                    }
                                }
                            
Département SI Salaire : 1000.0
Remarque !  Si vous accédez aux variables depuis une classe externe, vous devez accéder à la constante en tant que Personne.DEPARTMENT.

Inférence de type des variables locales

Qu'est-ce que l'inférence de type?

L'inférence de type fait référence à la détection automatique du type de données d'une variable, généralement effectuée au moment du compilation.

Qu'est-ce que l'inférence de type des Variables locales ?

L'inférence de type de variable locale est une fonctionnalité de Java 10 qui permet au développeur de passer la déclaration de type associée aux variables locales, et le type est déduit par le JDK. Le compilateur aura alors pour tâche de déterminer le type de données de la variable.

Comment déclarer des variables locales

Au lieu de mentionner le type de données de la variable sur le côté gauche, avant la variable, l’inférence de type de variable locale vous permet de mettre simplement le mot clé "var". Par exemple,

Exemple 6 :
                                public class Test{
                                    public void afficher(){
                                        // variable locale
                                        var val =3;
                                        System.out.println("val : " + val);
                                    }
                                    public static void main(String args[]){
                                        var T= new Test();
                                        T.afficher();
                                    }
                                }
                            

Il existe des cas où la déclaration de variables locales à l’aide du mot clé ‘var’ génère une erreur.

  •  Non autorisé dans les attributs de classe
                                            public class Test{
                                                var a; // erreur
                                            }
                                        
  •  Non autorisé pour les variables locales non initialisées
                                            public class Test{
                                                public void afficher(){
                                                    var a; // erreur
                                                }
                                                
                                            }
                                        
  •  Non autorisé en tant que paramètre pour les méthodes
                                            public class Test{
                                                public void afficher(var a){// erreur
    
                                                }
                                                    
                                            }
                                        
  •  Non autorisé dans le type de retour de méthode
                                            public class Test{
                                                public var getVal(){// erreur
                                                        
                                                }
                                                        
                                            }
                                        
  •  Non autorisé avec la variable initialisée avec 'NULL'
                                            public class Test{
                                                public void afficher(){
                                                    var val = NULL;
                                                            
                                                }
                                                            
                                            }
                                        

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :