Ecriture d'une instruction d'affectation en Java

En Java, on représente l'affectation par l'opérateur =. Le nom de la variable figure à gauche de = et la valeur qu'on veut lui affecter, à droite

Par exemple, affecter la valeur 33 à la variable Age s'écrira :

   Age = 33 ;

De manière générale, ce qui figure à droite de = est une expression. Une affectation s'écrit donc sous la forme:

    Nom de variable = expression ;

Une affectation est toujours exécutée de droite à gauche. C'est à dire que l'expression figurant à droite du signe = est d'abord évaluée et que sa valeur est ensuite enregistrée dans la variable dont le nom figure à gauche du =.

Notez également que la présence du point-virgule à la fin de l'affectation est obligatoire.

Exemple de code Java avec des affectations

Voilà un premier exemple de code Java, principalement composé d'affectations

 int Age, MonAge ;

 Age = 20 ;
 MonAge = 47 ; 
 Age = Age+1 ;
 Age = Age*2 ;
 MonAge = Age ;

Ce code commence par la déclaration de deux variables de type entier (Age et MonAge). Après la partie déclaration, on a cinq instructions d'affectation.

Comme la valeur par défaut du type int est 0, avant l'exécution de ces instructions les deux variables Age et MonAge valent 0.

Voilà comment se déroule ensuite l'exécution des affectations:

Affectations valides

Pour pouvoir affecter une expression à une variable, il faut que la variable soit de même type que l'expression. On ne pourra donc pas affecter une expression de type chaine de caractères à un int ou à un double (cela génère une erreur de compilation).

Il existe toutefois des exceptions pour les types numériques. Par exemple, si une variable est de type double, il est possible de lui affecter une expression de type int (voir type des expressions numériques). Dans ce cas, la valeur de l'expression sera automatiquement codée en un double avant d'être affectée à la variable.

Par contre, l'affectation d'une expression de type double à une variable de type int ne sera pas acceptée par le compilateur à cause d'un risque de perte d'information.

Prenons par exemple l'affectation suivante:

 x = 52.67;

où x est une variable de type int.

Pour affecter cette valeur à x, le compilateur pourrait prendre la partie entière de 52.67, c'est à dire 52. Il pourrait aussi prendre l'entier le plus proche, 53 dans notre exemple. Mais il y aurait de toutes facons une perte d'information, car le nombre 52.67 doit être approché par un nombre entier. La valeur exacte serait perdue. Le compilateur Javac, contrairement à d'autres langages (comme C par exemple) refuse simplement de faire cette approximation.

Affectation récursive

Dans une affectation, l'expression affectée à la variable peut elle même contenir la variable. On dit alors que l'affectation est récursive.

Exemple1

Ajouter le prix d'un article au prix total, se traduit par l'affectation récursive suivante:

 PrixTotal = PrixTotal + Prix ;

Exemple2 : Incrémentation et décrémentation

Augmenter la valeur d'une variable de 1, se dit incrémenter. C'est un cas particulier d'affectation récursive très fréquement utilisé en programmation.

Par exemple, pour incrémenter le nombre d'articles:

 NombreArticle = NombreArticle + 1 ;

De même, diminuer la valeur d'une variable de 1 est une affectation récursive appelé décrémentation.

L'instruction suivante par exemple, décrémente le nombre d'articles:

 NombreArticle = NombreArticle - 1 ;

Racourci d'écriture en Java

En Java différents opérateurs permettent de raccourcir l'écriture des affectations récursives.

Voilà donc les premiers exemples d'opérateurs unaires que nous rencontrons dans ce cours.

Traitement Iteratif

Les affectations récursives sont en général utilisées dans des traitements itératifs, c'est à dire des traitements que l'on répète plusieurs fois. Chaque répétition d'un traitement itératif s'appelle une itération.

Illustrons ceci par un exemple (si vous avez téléchargé les exemples de ce cours, vous trouverez ce projet dans le dossier Exemple-Java-Premieres-Notions\Album).

Considérons un programme permettant de calculer la durée totale des morceaux d'un album. Voici son interface graphique:

Un clic sur le bouton Ajouter provoque les opérations suivantes:

• Lecture du titre et de la durée du morceau.
• Affichage du morceau saisi dans les trois zones de texte (numéro du morceau dans la zone de texte de gauche, titre du morceau dans la zone de texte centrale, durée du morceau dans la zone de texte de droite)
• Augmentation de la durée totale de l'album par la durée de ce morceau.
• Affichage de la nouvelle durée totale

Nous avons ici un exemple de traitement itératif, puisque les mêmes opérations vont être effectuées chaque fois que l'utilisateur ajoute un morceau. Ou autrement dit, chaque fois qu'il clique sur le bouton Ajouter.

Voici, le code de la procédure évènementielle de ce bouton:

private void BT_AjouterActionPerformed
  (java.awt.event.ActionEvent evt) {                                           
  //--- Lecture des données
  
  Titre = es.Lire (CT_Titre);
  Duree = es.LireEntier (CT_Duree);

  //--- Traitement itératif
  
  DureeT = DureeT + Duree;
  Numero++;

  //--- Affichage
  
  es.Afficher(Numero, ZT_Num);
  es.Afficher (Titre, ZT_Titre);
  es.Afficher(Duree, ZT_Duree);
  es.Afficher(DureeT, CT_DureeT);

 }      

Et voici, la déclaration des variables du projet:

public class Album extends javax.swing.JFrame {
    
    String Titre; int Duree, Numero, DureeT;

Dans un traitement itératif, les valeurs de certaines variables sont recalculées à chaque itération à partir de leurs valeurs obtenues à l'itération précédente. Ce calcul se fait en général par des affectations récursives.

Dans notre exemple, il s'agit des variables DureeT (durée totale des morceaux) et Numero (numéro du morceau). Leurs valeurs sont recalculées à chaque itération par les deux affectations récursives suivantes:

  DureeT = DureeT + Duree;
  Numero++;

La première rajoute la durée saisie par l'utilisateur à la durée totale et la deuxième incrémente le numéro du morceau.

De manière générale, dans un traitement itératif, la suite des valeurs des variables mises à jour à chaque itération va dépendre de leurs valeurs initiales, ou plus précisément de leurs valeurs avant la première itération.

Dans notre cas, DureeT et Numero valent chacune zéro car elles ont été déclarées en tant que int et que la valeur par défaut de ce type de variable est zéro.

Dans notre exemple, la valeur par défaut convient très bien en tant que valeur initiale, mais ce n'est pas forcément le cas.

Imaginons par exemple que l'incrémentation du numéro se fasse après l'affichage, comme ceci:

private void BT_AjouterActionPerformed
  (java.awt.event.ActionEvent evt) {                                           
  //--- Lecture des données
  
  Titre = es.Lire (CT_Titre);
  Duree = es.LireEntier (CT_Duree);

  //--- Traitement itératif
  
  DureeT = DureeT + Duree;


  //--- Affichage
  
  es.Afficher(Numero, ZT_Num);
  es.Afficher (Titre, ZT_Titre);
  es.Afficher(Duree, ZT_Duree);
  es.Afficher(DureeT, CT_DureeT);
  
  Numero++;
 }      

Dans ce cas, le numéro du premier morceau sera 0 au lieu de 1. Pour corriger ceci, il faut initialiser la variable Numero, c'est à dire lui affecter une valeur avant la première itération.

En Java, il est possible d'initialiser une variable dans sa déclaration. Nous pourrions par exemple initialiser la variable Numero à 1 de la manière suivante:

public class Album extends javax.swing.JFrame {
    
    String Titre; int Duree, Numero = 1, DureeT;

De manière générale, vous pouvez même affecter la valeur d'une expression à une variable pour l'initialiser. La déclaration d'une variable peut donc s'écrire de la manière suivante:

 Nom du type  Nom de la variable  =  expression ;