Déclarer et initialiser les variables et les constantes

Les variables et les constantes en Java

Comme dans tout langage de programmation, des variables sont utilisées pour stocker les valeurs. Les constantes sont des variables dont les valeurs ne changent pas. Dans les sections suivantes, vous apprendrez comment déclarer des variables et des constantes dans Java.

Déclaration de variables

En Java, chaque variable a un type. Vous déclarez une variable en plaçant le type en premier, suivi du nom de la variable. En voici quelques exemples :

double salary;
int vacationDays;
long earthPopulation;
boolean done;

Notez le point-virgule à la fin de chaque déclaration. Le point-virgule est nécessaire car une déclaration est une instruction Java complète, et toutes les instructions Java se terminent par des points-virgules.

Un nom de variable doit commencer par une lettre et doit être une suite de lettres ou de chiffres. Notez que les termes “lettre” et “chiffre” sont beaucoup plus larges en Java que dans la plupart des langages.

Une lettre est définie comme ‘A’-‘Z’, ‘a’-‘z’ , ‘_’ , ‘_’ , ‘$’, ou tout caractère Unicode qui désigne une lettre dans une langue. Par exemple, les utilisateurs allemands peuvent utiliser des trémas tels que ‘ä’ dans les noms de variables ; les programmeurs grecs peuvent utiliser un π.

De même, les chiffres sont de ‘0’ à’9′ et tous les caractères Unicode qui désignent un chiffre dans une langue. Les symboles tels que ‘+’ ou ‘©’ ne peuvent pas être utilisés à l’intérieur des noms de variables, ainsi que les espaces aussi.

Tous les caractères du nom d’une variable sont significatifs et la casse est également significative. La longueur d’un nom de variable est essentiellement illimitée.

Si vous êtes vraiment curieux de savoir quels sont les caractères Unicode “lettres” en ce qui concerne Java, vous pouvez utiliser les méthodes isJavaIdentifierStart et isJavaIdentifierPartmethods de la classe Character pour vérifier.

Même si $ est une lettre Java valide, vous ne devez pas l’utiliser dans votre propre code. Il est destiné aux noms générés par le compilateur Java et d’autres outils.

Vous ne pouvez pas utiliser un mot réservé Java comme nom de variable.
A partir de Java 9, un seul trait de soulignement _ ne peut pas être utilisé comme nom de variable. Une future version de Java pourrait utiliser _ comme symbole générique.

Vous pouvez déclarer plusieurs variables sur une seule ligne :

int i, j ; // les deux sont des entiers

Cependant, nous ne recommandons pas ce style. Si vous déclarez chaque variable séparément, vos programmes seront plus faciles à lire.

Comme vous l’avez vu, les noms sont sensibles à la casse, par exemple, tva et tvA sont deux noms distincts. En général, vous ne devriez pas avoir deux noms qui ne diffèrent que par la casse de leurs lettres.

Cependant, il est parfois difficile de trouver un bon nom pour une variable. De nombreux programmeurs donnent alors à la variable le même nom que le type, par exemple

Box box ; // "Box" est le type et "box" le nom de la variable

D’autres programmeurs préfèrent utiliser un préfixe “a” pour la variable :

Box aBox ;

Initialisation des variables

Après avoir déclaré une variable, vous devez l’initialiser explicitement au moyen d’une instruction d’affectation – vous ne pouvez jamais utiliser la valeur d’une variable non initialisée.

Par exemple, le compilateur Java signale la séquence d’instructions suivante comme une erreur :

int vacationDays;
System.out.println(vacationDays); // ERREUR--variable non initialisée

Vous affectez une valeur à une variable précédemment déclarée en utilisant le nom de la variable à gauche, un signe égal (=), puis une expression Java avec une valeur appropriée à droite.

int vacationDays;
vacationDays = 12;

Vous pouvez déclarer et initialiser une variable sur la même ligne. Par exemple :

int vacationDays = 12;

Enfin, en Java, vous pouvez mettre des déclarations n’importe où dans votre code. Par exemple, le code suivant est valide en Java :

double salary = 65000.0;
System.out.println(salary);
int vacationDays = 12; // OK pour déclarer une variable ici

En Java, il est considéré comme un bon style de déclarer les variables aussi près que possible du point où elles sont utilisées pour la première fois.

A partir de Java 10, vous n’avez pas besoin de déclarer les types de variables locales si elles peuvent être déduites de la valeur initiale. Utilisez tout simplement le mot-clé var au lieu du type de la variable :

var vacationDays = 12;// vacationDays est un int
var greeting = "Hello"; // greeting est un objet de la classe String

C et C++ distinguent entre la déclaration et la définition d’une variable. Par exemple,

int i = 10 ;

est une définition, alors que

extern int i;

est une déclaration. En Java, les déclarations ne sont pas séparées des définitions.

Les constantes en Java

En Java, vous utilisez le mot-clé final pour désigner une constante. Par exemple :

public class Constantes
  {
    public static void main(String[] args)
      {
        final double CM_PAR_POUCE = 2.54 ;
                
        double largeurPapier = 8.5 ;
                
        double hauteurPapier = 11 ;
                
        System.out.println("Format du papier en centimètres : "
+ largeurPapier * CM_PAR_POUCE + " par " + hauteurPapier * CM_PAR_POUCE ) ;

      }
    
 }

Le mot-clé final indique que vous pouvez assigner une valeur à la variable une seul fois, puis sa valeur est définie une fois pour toutes. Il est courant de nommer les constantes en majuscules.

Il est probablement plus courant en Java de créer une constante pour qu’elle soit disponible pour plusieurs méthodes au sein d’une même classe. Ces constantes sont généralement appelées constantes de classe. Configurez une constante de classe avec les mots-clés static final. Voici un exemple d’utilisation d’une constante de classe :

public class Constantes2
  {
    public static final double CM_PAR_POUCE = 2.54 ;
    public static void main(String[] args)
      {
        double largeurPapier = 8.5 ;
        double hauteurPapier = 11 ;
        System.out.println("Format du papier en centimètres : "
+ largeurPapier * CM_PAR_POUCE + " par " + hauteurPapier * CM_PAR_POUCE ) ;
      }
 }

Notez que la définition de la constante de classe apparaît en dehors de la méthode main(). Ainsi, la constante peut également être utilisée dans d’autres méthodes de la même classe.

De plus, si la constante est déclarée, comme dans notre exemple, public, les méthodes d’autres classes peuvent aussi l’utiliser avec l’appel suivant: Constants2.CM_PER_INCH.

const est un mot-clé Java réservé, mais il n’est actuellement utilisé pour rien. Vous devez utiliserle mot-clé final pour déclarer une constante.

Types énumérés

Parfois, une variable ne devrait contenir qu’un ensemble restreint de valeurs. Par exemple, vous pouvez vendre des vêtements ou des pizzas en quatre tailles : petite, moyenne, grande et très grande.

Bien sûr, vous pouvez encoder ces tailles sous forme d’entiers 1, 2, 3, 4 ou de caractères S, M, L, et X. Mais c’est une configuration sujette aux erreurs. Il est trop facile pour une variable de tenir une valeur erronée (comme 0 ou m).

Vous pouvez définir votre propre type d’énumération chaque fois qu’une telle situation se présente. Un type énuméré a un nombre fini de valeurs nommées. Par exemple,

enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

Vous pouvez maintenant déclarer des variables de ce type :

Size s = Size.MEDIUM;

Une variable de type Size ne peut contenir qu’une seule des valeurs listées dans la déclaration du type, ou la valeur spéciale null qui indique que la variable n’est définie sur aucune valeur du tout.

LAISSER UN COMMENTAIRE

Please enter your comment!
Please enter your name here