précédent | suivant | table des matières s'évaluer

Types de donnée primitifs

Sommaire
  1. Types primitifs
    1. booléen
    2. char
    3. entier
    4. flottant
    5. conversions
  2. Variables et constantes
  3. Expressions

1 Types primitifs

Ce sont des types de donnée non objet qu'on retrouve dans de nombreux autres langages de programmation. A chacun de ces types correspond un type objet appelé «type enveloppe».

1.1 Booléen : boolean

C’est l’ensemble des deux valeurs true et false

1.2 Caractère : char  (visualisation, BabelMap)

Ensemble des valeurs unicode ( valeurs de ’\u0000’ à ’\uffff’ avec 4 chiffres obligatoires après ’\u’) Les 128 premiers caractères sont les codes ASCII et se notent entre apostrophes : ’a’, ’1’, ’\’’, ’\n’.

Compléments d’information sur Unicode, et aussi ici.

Un caractère est représenté sur 2 octets.

1.3 Types entiers

Les différents types entiers se distinguent par la taille de leur représentation.

Le codage des entiers se fait en binaire pour les entiers positifs et en binaire en complément à deux pour les entiers négatifs :

  • 9      est codé sur un octet en  00001001
  • -9     est codé sur un octet en  11110111
  • -1     est codé sur un octet en  11111111
  • -128 est codé sur un octet en  10000000
  • 127  est codé sur un octet en  01111111

Le codage des nombres négatifs en complément à deux s'obtient de la façon suivante :
  1. on représente la valeur absolue du nombre en binaire.
  2. on inverse tous les bits de la représentation.
  3. on ajoute 1.

Les littéraux peuvent être notée dans trois bases différentes : 

Les littéraux sont par défaut de type int. Un littéral peut être rendu de type long en le suffixant avec l ou L.

1.4 Types flottants

Ils se distinguent par la taille de leur représentation, et par conséquent par la précision et l’étendue des valeurs.

La représentation des réels est une représentation en virgule flottante : signe, exposant et significande ( IEEE754 ).

La valeur du nombre en représentation flottante est obtenue de la façon suivante :

float : ( 4 octets )  dans ce cas max vaut 255 : ensemble des nombres [-3.40282347E38 .. -1.40239846E-45], 0, [1.40239846E-45 .. 3.40282347E38] float
double : ( 8 octets ) dans ce cas max vaut 2047 : ensemble des nombres [-1.79769313486231570E308 .. -4.94065645841246544E-324], 0, [4.94065645841246544E-324 .. 1.79769313486231570E308] double

Les littéraux sont représentés de la façon suivante : 

    entier.{entier}{E{+, -}entier} ou .entier{E{+, -}entier}

Ce qui est entre accolades est facultatif. Par défaut un littéral flottant est de type double. Un littéral peut être forcée dans le type float en la suffixant avec f ou F ou dans le type double en la suffixant avec d ou D.

A la suite d’opérations en virgule flottante, on peut obtenir POSITIVE_INFINITY ou NEGATIVE_INFINITY, ou NaN ( Not a Number).

Les opérations sur les nombre flottants n’ont pas les même propriétés que les opérations habituellement utilisées sur les nombres réels ( commutativité, associativité, égalité ...) Voir :

Pour se rendre compte de certains des problèmes évoqués dans les articles précédents, essayer les programmes suivants :

avec des valeur initiales pour a et b qui sont des puissances de 4 + 0.1, pour d’autres valeurs, ou en changeant les double en float ...

  float A=3.1F,B=2.3F,C=1.5F;
  float     X,Y;
  X=(A*B)*C;
  Y=A*(B*C);
  System.out.println(X);
  System.out.println(Y);
  System.out.println();
  System.out.println(4096.1F-4095.1F);
  System.out.println(4096.1-4095.1);
les sorties console sont les suivantes :
10.695
10.694999

1.0
1.0000000000004547

A essayer avec des valeur initiales pour a et b qui sont des puissances de 4 + 0.1, pour d’autres valeurs, ou en changeant les double en float ...

public void xxx(){
   double a = 64.1;
   double b = 63.1;
   // pour d’autres valeurs de a et b 
   // la suite des  x est (1, 1, 1, ...
   double x = 1.0; 
   for (int i=1; i <= 14; i++){
      System.out.println(""+i+"  "+x);
      x = a*x - b;// b = a-1  donc x = b*(x-1)+x
                  // x initial = 1, donc x = x = 1
   }
}
1  1.0
2  0.9999999999999929
3  0.9999999999995381
4  0.9999999999703917
5  0.9999999981021048
6  0.9999998783449158
7  0.9999922019090874
8  0.9995001423725043
9  0.967959126077524
10  -1.05382001843072
11  -130.64986318140916
12  -8437.756229928327
13  -540923.2743384057
14  -3.4673244985091805E7

1.5 Conversions

Les conversions vers un type dont la taille de la représentation est plus grande ou égale se font automatiquement sans avoir besoin d’être spécifié.

Dans l'image ci-contre, les flèches pleines indiquent les conversions automatiques sans perte d'information, les flèches en pointillés, les conversions automatiques avec une possible perte d'information : conversions automatiques

Les autres conversions peuvent entraîner une perte d’information, et doivent être spécifiées par un opérateur de cast.

Exemples : 

double d = 12345.6;
byte b = (byte)d; // b vaut 57

2 Variables, constantes

Une variable doit être déclarée. Une déclaration est un type suivi du nom de la variable. Le nom peut être suivi d’une initialisation ( = valeur).

Une déclaration de constante se fait comme une déclarationde variable précédée du mot final.

Un nom de variable ou de constante est contitué de lettres, de chiffres de '_', et de symboles monétaires ('$', '£', '€', etc... ) et ne peut pas commencer par un chiffre. Plus généralement la méthode Character.isJavaIdentifierStart(Char c) retourne true si c peut commencer un identificateur, et la méthode Character.isJavaIdentifierPart(Char c) retourne true si c peut faire partie du reste de l'identificateur.

L'identificateur ne peut pas être un mot réservé Java :

abstract continue for new switch
assert default goto package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp volatile
const float native super while
On représente les variables ou constantes de type primitifs de la façon suivante :
int i = 12;
double d = 3.14;

Par convention les noms de variable, attributs, paramètres commencent par une minuscule, les nom de classe, d'interface et d'énumération commencent par une majuscule. Quand un identificateur est composé de plusieurs mots, tous les mots sauf le premier commencent par une majuscule.


3 Expressions   (visualisation)

Les expressions sont construites à partir de littéraux, variables, constantes, opérateurs et parenthèses. Toute les expressions retourne une valeur. Les expressions ( sauf pour les opérateurs && et || ) sont évaluées en évaluant d’abord l’opérande de gauche, puis l’opérande de droite, puis en réalisant l’opération.

int i = 0 ;
t[++i]=++i ; // affectation de 2 à t[1]

Certaines instructions sont des instructions expressions et peuvent se trouver partout où on peut trouver une instruction : 

opérateur
sémantique
priorité
associativité
[] . () appel de méthode
sélection dans un tableau, sélection d'un attribut ou méthode de classe, et paramètre d'un appel de méthode
0
gauche vers droite
++ --
Pré ou post incrémentation ou décrémentation
1
droite
+ - unaire
 
1
droite
!
négation booléenne
1
droite
~
Négation bit à bit
1
droite
() cast
Transtypage.
1
droite
*
Multiplication
2
gauche
/
Division : division réelle si un des deux opérandes est un réel, et quotient de la division si les deux opérandes sont des entiers. Une division par 0 lève une exception.
2
gauche
%
Reste de la division. (opérandes entiers ou réels)
2
gauche
+ - binaires
addition et soustraction.
3
gauche
<< >>
Décalage à gauche signé, complété par des 0, décalage à droite signé, le remplissage dépend du signe.
  • 32>> 3 = 4
  • -32 >> 3 = -4
4
gauche
>>>
Décalage à droite, le remplissage se fait avec de 0.
  • 32 >> 3 = 4
  • -32 >>> 3 = 536870908
4
gauche
< <= > >=
Opérateurs de comparaison.
5
gauche
== !=
Opérateurs de comparaison.
6
gauche
&
Et bit à bit pour les opérandes entiers.
Et évaluant les 2 opérandes pour des opérandes booléens.
7
gauche
^
Ou exclusif bit à bit pour des opérandes entiers.
Ou évaluant les 2 opérandes pour des opérandes booléens.
8
gauche
|
Ou inclusif bit à bit pour des opérandes entiers.
Ou inclusif évaluant les 2 opérandes pour des opérandes booléens.
9
gauche
&&
Et logique. le premier opérande est évalué : s’il vaut false la valeur de l’expression est false, sinon c’est la valeur du second opérande.
10
gauche
||
Ou logique. le premier opérande est évalué : s’il vaut true la valeur de l’expression est true, sinon c’est la valeur du second opérande.
11
gauche
? :
Opérateur ternaire a ? b : c
  • a est évalué
    • a vaut true la valeur de l’expression est la valeur de b
    • a vaut false la valeur de l’expression est la valeur de c
b est une expression quelconque, mais c ne peut être une affectation que si elle est entre parenthèses.
12
droite vers gauche
=  +=  -= &=
*=  /=  %=
<<=  >>=  >>>=  
&=  |=  ^=
Opérateurs d’affectation : la partie gauche doit être une variable.
Les opérateurs composés ont le sens suivant :
a op= b est équivalent à a = (T)(a op ( b ))T est le type de a. L’expression b est évaluée avant de d’évaluer a op b ;
String s; s += ’a’+’b’; est équivalent à s = s+(’a’+’b’).
13
droite vers gauche
instanceof
a pour valeur true si l’opérande de gauche a pour type l’opérande de droite et false sinon.
14
gauche
cast
 
1
gauche
new
 
1
gauche

Les opérations sur les nombres réels ne lèvent pas d’exceptions, mais produisent des valeurs NaN, POSITIVE_INFINITY ou NEGATIVE_INFINITY

float a = 1000f;
System.out.println(a/0); // affichage de Infinity
a = a*a*a*a; 
System.out.println(a);   // affichage de 1.0E12
a = a*a*a*a; 
System.out.println(a);   // affichage de Infinity
System.out.println(a/a); // affichage de NaN


haut de la page