Définitions

Type

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 :

les valeurs
les valeurs du type sont tous les entiers entre \(-2^{31}\) et \(2^{31}-1\) ;
les opérations
les opérations associées sont ici les calculs classiques sur les entiers, à savoir l'addition +, 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.

Types fondamentaux en Java

Java possède huit types fondamentaux. Nous utiliserons surtout :

int
les entiers relatifs
boolean
les valeurs de vérité (true et false, avec des opérations logiques associées)
double
une approximation des nombres réels de \(\mathbb{R}\) avec les opérations de calcul associées
char
un caractère

Variable

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.

Valeurs littérales

Principe

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.

Exemples

  • pour le type 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 ;
  • pour le type boolean, on a seulement deux valeurs dont les littéraux sont true et false ;
  • pour le type 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\)).

Manipulations élémentaires des variables

Déclaration

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.

Affectation

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.

Obtenir la valeur

Pour lire le contenu d'une variable, il suffit d'écrire son nom. Par exemple x=y s'interprète comme suit :

  • le signe = est l'opération d'affectation ;
  • le x à gauche du signe égal est obligatoirement le nom d'une variable (sinon l'affectation est incorrecte) ;
  • le 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.

Exemple

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

Expressions

Présentation

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 :

  • des valeurs littérales ;
  • des variables (plus précisément des identificateurs de variables) ;
  • des opérateurs (du type +, *, tout ce qui est possible selon le type des valeurs/variables concernées) ;
  • des parenthèses (pour gérer l'ordre des calculs).

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.

Évaluation d'une expression

Évaluer une expression, c'est lui associer une valeur. L'évaluation se fait en deux temps :

  1. on commence par remplacer chaque identificateur de variable par la valeur de la variable correspondante ;
  2. on réalise alors le calcul proprement dit, sachant que l'expression ne contient maintenant que valeurs littérales, des opérateurs et des parenthèses.

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 :

  1. on remplace les x par 12, ce qui donne 2*12+3+12
  2. on calcule 2*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).

Exemple

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.

Types et printf

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 :

%d
correspond aux valeurs entières, soit le type int mais aussi short, byte et long
%f
correspond aux nombres réels, soit les types double et float
%c
correspond au type caractère char (un seul caractère)
%s
correspond aux chaînes de caractères, soit le type objet String
%b
correspond aux valeurs de vérités, soit le type boolean

Dans certaines circonstances, une conversion sera automatiquement réalisée par Java, mais il vaut mieux respecter strictement les règles ci-dessus.