En programmation, un type définit un ensemble de valeurs et un ensemble
d'opérations associées à ces valeurs. Par exemple le type int de Java
correspond à un sous-ensemble de \(\mathbb{Z}\), plus précisément :
+, la soustraction
- et la multiplication *. Le type propose aussi la
division Euclidienne avec l'opérateur / qui donne le
quotient et l'opérateur % qui donne le reste.Java possède huit types fondamentaux. Nous utiliserons surtout :
intbooleantrue et false, avec des opérations
logiques associées)doublechar
En Java, une variable est un emplacement de la mémoire de l'ordinateur
destiné à contenir une valeur. Le type de la variable indique le type des
valeurs contenues dans celle-ci. Chaque variable est identifiée par un nom,
l'identificateur de la variable. Le nom de la variable ne peut pas changer
au cours de l'exécution d'un programme. Au contraire, sauf cas particulier
d'une variable static, la valeur contenue dans la variable peut changer au
cours du programme.
Pour spécifier une valeur d'un certain type dans un programme, on utilise une valeur littérale. Il s'agit simplement d'écrire une valeur dans le texte du programme. Chaque type qui possède des valeurs littérales utilise une syntaxe particulière pour celles-ci.
int, une valeur littérale est simplement un entier écrit en
base 10 (avec éventuellement le signe - en préfixe), comme par exemple
12, -2223324, 123813283 ;boolean, on a seulement deux valeurs dont les littéraux
sont true et false ;double, on utilise une notation proche de la notation
scientifique, par exemple 1.5 e 5 correspond à \(1,5\ 10^{5}\) (plus
simplement -0.034 correspond à \(0,034\)).Pour pouvoir utiliser une variable, il faut la déclarer. La forme générale de la déclaration est :
T id;
Ceci correspond à déclarer une variable de nom id et de type T. Par
exemple les lignes
int x;
double z;
boolean t;
déclarent trois variables, x de type int, z de type double et t de
type boolean.
Pour fixer la valeur d'une variable, on utilise une opération
d'affectation représentée par le symbole =. La forme générale de
l'affectation est
id = v;
Dans cette ligne, id doit être l'identificateur d'une variable et v une
valeur (par exemple une valeur littérale) d'un type compatible avec celui de
la variable. L'effet de l'instruction est de fixer la valeur de la variable
id à v. Par exemple si on exécute les lignes suivantes
int x;
x = 4;
boolean t = true;
on crée deux variables, x de type int et t de type boolean, et on
fixe leur valeur, soit 4 pour x et vrai pour t. On remarque qu'on peut
déclarer et affecter une variable en un seul coup.
Pour lire le contenu d'une variable, il suffit d'écrire son nom. Par exemple
x=y s'interprète comme suit :
= est l'opération d'affectation ;x à gauche du signe égal est obligatoirement le nom d'une variable (sinon
l'affectation est incorrecte) ;y à droite du signe égal est interprété comme une valeur (selon les
règles de l'affectation) : l'ordinateur lit le contenu de la variable y
et remplacer l'identificateur y par cette valeur, avant d'affecter le
résultat à la variable x.Le programme suivant
public class Affectation {
public static void main(String[] args) {
int x = 2;
System.out.println(x);
int y = 3;
System.out.println(y);
y = x;
x = 4;
System.out.println(x);
System.out.println(y);
}
}produit cet affichage :
2 3 4 2
On peut réaliser des affectations plus complexes en passant par des expressions. En première approximation, une expression est un calcul plus ou moins complexe. Une expression contient :
+, *, tout ce qui est possible selon le type
des valeurs/variables concernées) ;Quelques exemples d'expression :
5 : valeur littérale 5 ;x + 2 : addition avec une variable x et une valeur littérale 2 ;(y > 2) && (z + 3 < 4) : calcul logique composé d'un et logique
appliqué aux résultats de deux comparaison faisant intervenir les variables
y et z.Évaluer une expression, c'est lui associer une valeur. L'évaluation se fait en deux temps :
Si on dispose par exemple d'une variable x de type int contenant la
valeur 12, l'expression 2*x+3+x est évaluée comme suit :
x par 12, ce qui donne 2*12+3+122*12, soit 24 qu'on ajoute à 3, ce qui donne 27 puis à
12 qui donne 39.Une fois l'expression évaluée, tout se passe comme si on la remplaçait par la valeur obtenue. On peut donc écrire
int u = 3;
int v = 4;
int w;
w = u + v * (u - 1);
en effet, l'expression u + v * (u - 1) est d'abord évaluée (ce qui donne
ici 11), puis on place la valeur obtenue dans la variable w. De la même
façon, on peut « afficher » une expression, au sens où l'expression sera
évaluée puis le résultat affiché par un appel à System.out.println (cf
l'exemple suivant).
Le programme suivant
public class Expression {
public static void main(String[] args) {
int u = 2;
int v = u + 1;
System.out.println(v - 2);
boolean z = u >= v;
System.out.println(z);
u = 3;
System.out.println(u);
System.out.println(v);
}
}produit cet affichage :
1 false 3 3
On constate en particulier que l'affectation v = u + 1 n'est pas
symbolique, c'est-à-dire que le contenu de la variable v n'est pas défini
comme étant toujours égal au contenu de la variable u auquel on
ajoute 1. Au contraire, la variable v n'a aucune connaissance de la forme
de l'expression u + 1. Pour définir le contenu de v, on évalue
l'expression u + 1 au moment de l'affectation (c'est-à-dire quand u
vaut ici 2) et on écrit le résultat dans v. De que cela est fait,
l'expression est totalement « oubliée » et v ne contient que la valeur 3
sans aucune référence à la façon dont elle a été obtenue. De ce fait, on peut
changer la valeur de u sans aucune influence sur celle de v.
L'utilisation de la méthode printf pour l'affichage demande de connaître le
type des valeurs à afficher. En effet, chaque code d'affichage (de la forme
%x) est associé à un ensemble de types selon les règles suivantes :
%dint mais aussi
short, byte et long%fdouble et float%cchar (un seul caractère)%sString%bbooleanDans certaines circonstances, une conversion sera automatiquement réalisée par Java, mais il vaut mieux respecter strictement les règles ci-dessus.