Types primitifs en Java

Dans la version 32 bits, la plage représentable doit être calculée en pensant à un bit de signe, une mantisse à 23 bits et un exposant à 8 bits avec des valeurs comprises entre -126 et 127.

De plus, la norme prévoit la représentation de deux valeurs pour zéro (de droite et de gauche), deux pour l'infini (positif et négatif), et des valeurs NaN (not a number) à utiliser par exemple comme résultats d'opérations impossibles (par exemple, des divisions par zéro).

Type	Quantité de mémoire	Information représentée	Valeur par défaut
byte	8 bits	Variable avec signe (avec représentation "two's complement", complément à deux) et représente des valeurs dans une plage `[-128 et 127]` (extrémités incluses)	`0`
short	16 bits	Nombres entiers (avec signe) dans une plage `[-32 768, 32 767]`	`0`
int	32 bits	Nombres entiers (par défaut avec signe, signed) dans une plage `[-2³¹, 2³¹-1]`. Avec Java 8, il a été introduit la possibilité d'utiliser les int pour représenter des quantités unsigned qui pourront avoir une plage `[0, 2³²-1]` (grâce à des méthodes statiques introduites dans les classes Integer et Long)	`0`
long	64 bits	Nombres entiers (par défaut avec signe, signed) dans une plage `[-2⁶³, 2⁶³-1]`. Comme pour les entiers en Java 8, il existe la possibilité de les utiliser comme des quantités unsigned avec une plage (positive) qui arrive jusqu'à `2⁶⁴-1`.	`0L`
float	32 bits	Nombres à virgule flottante en simple précision selon la spécification IEEE 754, en utilisant la représentation signe, mantisse, exposant. `(-1)^signe * mantisse * 2^exposant`		`0.0f`
double	64 bits	Nombres à virgule flottante en double précision selon la spécification IEEE 754. La précision avec laquelle les nombres sont représentés augmente en vertu de l'augmentation du nombre de bits utilisés.	`0.0d`
boolean	non spécifié, mais un seul bit suffirait	sert à représenter uniquement 2 valeurs : vrai ou faux (`true` ou `false`).	`false`
char	16 bits	Est utilisé pour la mémorisation de caractères du jeu de caractères Unicode) dans la plage `['', '']` (en hexadécimal) ou équivalent `[0,65535]`.

Exercice

/* je déclare trois types de variables différentes pour tester leur fonctionnement
*
* j'exécute en deuxième instance le suivant exercice pour tester le fonctionnement
* du cycle while
*
* a) j'imprime les nombres de 1 à 10 et
* b) j'imprime les nombres de 1 à 20 et atteint le 20 continue à imprimer de manière
* décroissante de 20 à 1
* c) j'imprime les nombres impairs entre 1 et 100
* d) j'imprime les nombres de 1 à 100 en mettant en évidence les nombres multiples de 25
* e) j'imprime les nombres de 1 à 100 de manière consécutive sur une seule ligne en mettant en évidence les multiples de 100
* f) j'imprime les nombres de 100 à 1 en mettant en évidence les multiples de 7
*
*
* */

public static void main(String[] args) {

// byte gère les nombres de -128 à +127
// int char
byte a;
a=-128;
//System.out.println(a);
//nous avons testé que le nombre géré par byte
// va de -128 à +127

int b;
b=+2147483647;
// System.out.println(b);

char c;
c='@';
int contatore=0;
while(contatore<=1000)
{
System.out.print(contatore + " \
System.out.print(c);
contatore++;
}

}

Ressources en ligne sur le sujet :

http://www.di-srv.unisa.it/professori/masucci/LPII-0405/slides/Lez03.pdf