Les littéraux

L'écriture des littéraux obéit à un certain nombre de conventions qui dépendent du type et du langage de programmation. Nous présentons ici celles du langage Java.

Les littéraux numériques

Un littéral numérique représente la valeur d'un nombre.

Pour le compilateur Java, une suite de chiffres éventuellement précédée d'un signe - ou +, est considérée comme un littéral de type int. Exemple de littéraux de ce type: 2015, -1961, + 1935.

Pour écrire des nombres non entiers on utilise le point (et non pas la virgule !). La partie entière du nombre est suivi d'un point, puis d'une autre suite de chiffres. Exemples: 213.141559, -5.33333. Les nombres écrits de cette manière sont interprétés comme des littéraux de type double.

Pour pouvoir écrire des nombres très grands ou très petit, java autorise également la notation scientifique (voir codage par virgule flottante), avec la lettre e ou E pour désigner l'exposant. Par exemple 1.7 10³⁰⁸, s'écrit 1.7E+308 ou 1.7e+308. Des nombres écrits de cette manière sont également interprétés comme des littéraux de type double.

Les littéraux de type chaine de caractères

En Java, un littéral de type chaine de caractères s'écrit entre guillemets.

Par exemple "Il fait beau", "4012", "(3 x + 1)", "VisualC++", "@%^š€" sont des littéraux de type chaine de caractères.

On remarquera que tous les caractères sont autorisés entre les guillemets sauf les guillemets eux mêmes !. Pour mettre un guillemet dans une chaine de caractères, il faut le faire précéder par un anti-slash (le caractère \).

Parmis les chaines de caractères, il y en a une qui joue un rôle particulier : la chaine vide.

Attention: a priori on pourrait penser que la chaine vide est la valeur par défaut des variables déclarées en tant que chaine de caractères (type String). En fait, la valeur par défaut pour le type String est null. A ce stade, nous ne pouvons pas expliquer clairement ce que représente null (nous reviendrons la dessus dans le cours consacré à la programmation objet), mais sachez en tout cas, qu'il ne s'agit pas d'une chaine de caractères !

Les Constantes

Une constante est donc en quelque sorte le synonyme d'une valeur. On pourra par exemple introduire une constante PI représentant le nombre 3.14159.

Comme son nom l'indique, la valeur d'une constante ne peut pas varier durant l'exécution d'un programme.

Déclaration d'une constante en Java

En Java, une constante peut se déclarer de la manière suivante:

  final type de la constante nom de constante = littéral ;
 

Le nom d'une constante obéit aux même règles que le nom d'une variable.

Exemple

    final double PI = 3.14159 ;
    final String CLEF_USB = "F:" , DISQUE_DUR = "C:";
 

Notez que les programmeurs utilisent souvent des majuscules pour les noms des constantes, afin de les distinguer immédiatemment des variables. En adoptant cette convention vous rendrez vos programmes plus lisibles.

Où faut-il déclarer les constantes ?

Comme pour la déclaration des variables, les déclarations de constantes peuvent figurer en de nombreux endroits d'un programme. Je vous propose de les déclarer dans la zone de déclaration.

Voici par exemple la déclaration des constantes dans le projet Peinture que nous verrons un peu plus loin en détails:

 public class Peinture extends javax.swing.JFrame {
         
    // Déclaration des constantes
    
    final double 
    LARGEUR_FENETRE = 1.4, HAUTEUR_FENETRE = 1.2,
    LARGEUR_PORTE = 0.9, HAUTEUR_PORTE = 2.1,
    HAUTEUR_MUR = 2.5;

Operateur

Voici par exemple, quelques opérateurs fréquement rencontrés dans les langages de programmation: +   -  /  *  ^  =  ++  !   %

Dans ce cours, nous nous concentrerons pour l'instant sur les opérateurs suivants:

• L'opérateur d'addition, représentée par le caractère + .
• L'opérateur de soustraction, représenté par le caractère -
• L'opérateur de multiplication, représenté par le caractère * (et non pas × comme en mathématique !).
• L'opérateur de division, représenté par le caractère /
• l'opérateur de concaténation, représenté par le caractère +

Vous connaissez déjà les quatre premiers opérateurs puisqu'il s'agit des opérateurs mathématiques classiques. Mais si vous n'avez jamais fait de programmation, vous ignorez probalement le sens de l'opérateur de concaténation. Nous en reparlerons plus loin.

Les opérateurs précédents sont tous des opérateurs binaires, c'est à dire qu'ils nécessitent deux données pour effectuer l'opération correspondante. Ces deux données s'appellent les opérandes.

En Java, une des deux opérandes figure avant l'opérateur et l'autre après. Comme par exemple 2 + 7, 3 * 9, etc .. Lorsqu'on a un opérateur binaire, on a donc forcément une opérande gauche et une opérande droite. Cela vous paraitra certainement naturel, mais sachez que d'autres langages (comme Lisp par exemple) utilisent une notation préfixée. C'est à dire que l'on écrira l'opérateur avant les deux opérandes ( par exemple + 2 7 à la place de 2 + 7).

Nous verrons ultérieurement qu'il existe également des opérateur unaires, c'est à dire des opérateurs qui ne nécessitent qu'une seule opérande.

La division euclidienne

Attention à l'opérateur de division: il se comporte de manière différente selon le type des nombres à diviser. Si au moins un des deux nombres n'est pas un entier, ce sera la division habituelle. Par contre, si les deux nombres à diviser sont entier, cet opérateur effectue la division euclidienne (également appelée division entière) des deux nombres. Par exemple:

• 7 / 2 vaut 3 (et non pas 3.5 !), car 7 = 3 X 2 + 1.
• 1 / 2 vaut 0 (et non pas 0.5 !), car 1 = 0 X 2 + 1

Si vous ne voulez pas avoir la division euclidienne, il suffit d'écrire un des deux nombres avec un point à la fin. Il ne sera alors pas considéré comme un nombre entier par le compilateur. Par exemple, 1 / 2. vaudra 0.5.

La concaténation

Par exemple, si je concatène la chaine "para" avec la chaine "pluie", j'obtient la chaine "parapluie".

La manière de noter l'opérateur de concaténation dépend des langages.

En Java, il se note comme l'opérateur d'addition, c'est à dire avec un signe +.

L'opérateur de concaténation permet de construire des expressions de type chaine de caractères.

Par exemple, "Je suis " + Prenom est une expression de type chaine de caractères constituée d'un littéral ("Je suis "), de l'opérateur de concaténation + et d'un nom de variable (Prenom).

On peut concaténer autant de chaines de caractères qu'on le souhaite. Par exemple, dans l'expression "Je suis "+Prenom+" "+Nom il y a quatre chaines de caractères.

Voilà différentes valeurs de l'expression

 "Je suis " + Prenom

pour différentes valeurs de la variable Prenom :

Voilà différentes valeurs de l'expression

 "Je suis " + Prenom + " " + Nom

pour différentes valeurs des variables Prenom et Nom :

Validité d'une expression

L'écriture d'une expression dans un certain langage de programmation doit nécessairement obéir aux règles propres à ce langage.

Nous donnons ici, un certain nombre de règles non exhaustives permettant d'écrire des expressions valides en Java.

Expressions valides de type chaine de caractères

Les règles suivantes permettent de construire des expressions de type chaine de caractères valides:

Exemples d'application de ces règles (Nom et Prenom sont des variable de type String et Age est une variable de type int):

Expressions valides de type numérique

Les règles suivantes (non exhaustives) permettent de construire des expressions numériques valides:

Exemples d'application de ces règles (avec Nom de type String, Age de type Integer et Poids de type Double):

Type des expressions numériques

Dans ce cours, nous nous limitons aux deux types numériques int et double. Dans certaines situations, il peut être important de connaitre le type exacte d'une expression numérique. Pour cela, vous pouvez utiliser les règles suivantes:

Exemple

Supposons que l'on ait des variables i et j de type int et x et y de type double. Alors:

• i * j est de type int, car i et j le sont.
• i + x est de type double, car x est de type double.
• i / 2.5 est de type double car 2.5 est de type double.
• 12 - (i * j) est de type int car 12 est de type int et i * j aussi
• j * (i + x) est de type double, car i + x est de type double

Affichage d'expression

Affichage dans un champ ou une zone de texte

Nous avons vu que "l'instruction" es.Afficher de la librairie JavaETBib permet d'afficher la valeur d'une variable dans un champ de texte ou une zone de texte. En fait, elle est plus générale que cela, car elle permet d'afficher la valeur d'une expression quelconque (de type chaine de caractères ou numérique).

Revenons sur le schéma lecture-traitement-affichage. A présent, nous pouvons expliquer comment afficher les résultats d'un traitement sans les sauvegarder dans des variables: il suffit d'écrire l'expression du traitement à l'intérieur de l'instruction d'affichage !

Voilà par exemple comment écrire le programme d'addition (voir l'exercice de prise en main de NetBeans) sans sauvegarder le résultat dans une variable:

private void BoutonAdditionnerActionPerformed( .... {                                                  

  x = es.LireEntier(ChampTexteX);
  y = es.LireEntier(ChampTexteY);

  es.Afficher(x+y, ChampTexteSomme);
 }    

Le calcul de l'addition se fait à l'intérieur de l'instruction d'affichage.

Dans des cas simples, cette manière de programmer peut être utilisée. Mais de manière générale, essayez autant que possible de séparer le traitements des données et l'affichage. Vous obtiendrez ainsi des programmes plus lisibles et plus faciles à modifier.

Affichage dans une boite de dialogue

De même l'instruction es.AfficherMessage, permet non seulement d'afficher la valeur d'une variable, mais également celle d'une expression.

Nous allons illustrer ceci en reprenant l'exemple du projet Population ( Si vous avez téléchargé les exemples de ce cours, vous trouverez ce projet dans le dossier Java-Exemple-Premieres-Notions/Population). L'utilisateur saisi le nom d'une ville, sa population (en milliers d'habitants) et son code postal. Par exemple, pour Strasbourg:

S'il clique ensuite sur le bouton Lire (pour enregistrer ces données en mémoire dans les variables Ville, NH et CP), puis sur le bouton Afficher phrase, le message suivant s'affiche dans une boite de dialogue:

Ce résultat est obtenu grâce à l'affichage d'une expression de type chaine de caractères construite à partir des valeurs des variables Ville, NH et CP. Voici le code de la procédure évènementielle associée au bouton Afficher phrase:

 private void BT_AfficherPhraseActionPerformed
   (java.awt.event.ActionEvent evt) {                                                    
        es.AfficherMessage("La ville "+ Ville + 
                           " (CP " + CP + ") a " + NH + 
                           " milliers d'habitants");
    }     

Les parties fixes de la phrases sont entre guillemets. Ce sont les quatre chaines de caractères "La ville ", " (CP ", ") a " et " milliers d'habitants". Les parties dépendantes des données sont construites à partir des valeurs des variables Ville, CP et NH. Notez bien que Java traduit automatiquement les variables numériques en chaines de caractères (sans quoi la concaténation n'aurait pas de sens!).

Notez également que es.AfficherMessage ne permet pas d'afficher une expression numérique.