1.3 Valeurs et expressions

Une valeur, c'est le résultat de l'évaluation d'une expression : ce sont les valeurs qui sont passées en argument à une fonction, ou retournées comme résultat d'une fonction. Les valeurs se répartissent en deux catégories :

• les valeurs primitives,
• les références, qui sont
  • des références à des tableaux (Cf. § ), ou
  • des références à des instances de classe (Cf. chap. ).

Les valeurs peuvent aussi être stockées dans des variables, notion qui a une importance particulière dans le style impératif (Cf. chap. ). Dans les figures, les variables sont représentées par des boîtes rectangulaires.

1.3.0.0.1 Types primitifs

Les valeurs primitives sont celles de tout langage de programmation : nombres entiers, nombres flottants, caractères. Ce sont les valeurs dont le type est l'un des types primitifs de Java :

void

: aucune valeur n'est de ce type

boolean

: deux valeurs, true et false

char

: les caractères Unicode

byte

: les nombres entiers 8 bits

short

: les nombres entiers 16 bits

int

: les nombres entiers 32 bits

long

: les nombres entiers 64 bits

float

: les nombres flottants 32 bits

double

: les nombres flottants 64 bits

Figure: Variables initialisées par des valeurs primitives.

La représentation des valeurs primitives sera détaillée au § . Une variable de type primitif a de plus la particularité de pouvoir être initialisée par une expression constante, par exemple (figure ) :

   boolean test = false;
   char c = 'A';
   int m = 23;
   double x = 3.14;

On notera que dans une déclaration de variable, le type précède le nom, à la façon des adjectifs en anglais.

1.3.0.0.2 Sous-typage des types primitifs

Il existe des relations de sous-typage entre certains des types primitifs : chacun des types byte, short, int, long, float, double est un sous-type des suivants et char est un sous-type de int. Ces relations permettent de convertir une valeur d'un type en une valeur d'un sur-type : une telle conversion peut se faire sans perte d'information dans certains cas (de byte en short, de short ou de char en int, de int en long, de float en double) ou avec perte d'information dans les autres cas, l'ordre de grandeur étant cependant préservé (par exemple, de int en float).

1.3.0.0.3 Expressions

Java dispose d'un grand nombre de catégories d'expression, qui sont toutes construites à partir de noms (de type, de variable, etc. ), de constantes littérales et d'opérateurs. Citons, parmi d'autres :

• les expressions arithmétiques (par exemple, a - 2*b)
• les expressions booléennes (par exemple, a<b/2 || a>=b)
• les affectations (par exemple, a = b+1)
• les expressions de création (par exemple, new int[4], voir § )
• les sélections d'un champ (par exemple, t.length, voir § )
• les invocations de fonctions (par exemple, Math.random())
• les transtypages (par exemple, (double)m)

Chaque catégorie d'expression a ses propres règles d'évaluation. L'évaluation d'une expression de type $t$, si $t$ est différent de void, produit une valeur de type $t$ ou d'un sous-type de $t$. Cette propriété, dite de sûreté de typage est un facteur essentiel de sécurité (Cf. § ). Notons que l'évaluation d'une expression de type void ne produit pas de valeur.

1.3.0.0.4 Affectation

L'expression var = exp n'est correctement typée que si le type de exp est égal au type de var ou en est un sous-type. La valeur de var = exp est celle de exp. Cette évaluation a en outre pour effet d'écrire cette valeur dans la variable var, autrement dit, d'affecter cette valeur à var. La propriété de sûreté de typage garantit alors que la valeur affectée à var est du même type que var ou en est un sous-type.

1.3.0.0.5 Transtypage

Si $t$ est un type et $E$ une expression, l'expression $\mathtt{(}t\mathtt{)}E$ est appelée expression de transtypage (en anglais informatique, cast). Elle n'est généralement définie que si $t$ est un sur-type (transtypage ascendant) ou un sous-type (transtypage descendant) du type de $E$. Quand elle est définie, l'expression $\mathtt{(}t\mathtt{)}E$ est de type $t$. Par exemple, pour effectuer une opération flottante quand les opérandes sont entières, il faut d'abord appliquer un transtypage en double à l'un des opérandes : alors que 5/2, c'est-à-dire la division entière de 5 par 2 a pour valeur 2, (double)5/(double)2 a pour valeur $2.5$, car c'est la division flottante de 5.0 par 2.0. Notons que (double)5/2 et 5/(double)2 ont aussi pour valeur $2.5$, car il y a promotion de 2 en 2.0 dans le premier cas, de 5 en 5.0 dans le second (voir § ). Il existe des transtypages entre tous les types numériques. Pour ces types, l'évaluation d'une expression de transtypage réalise une conversion, c'est-à-dire une transformation, de la valeur. Les conversions descendantes, par exemple de int vers byte, ou de double vers int, peuvent conduire à une perte d'information par troncature. Les conversions entre float et int peuvent induire un perte d'information, bien que ces deux types aient la même taille.