Programmation Java/Types de base

Les types de base ou types primitifs de Java sont listés dans le tableau plus bas.

Remarques :

  • Une constante numérique de type entier est considérée comme étant de type int. Il faut ajouter le suffixe L pour avoir une constante de type long.
  • La base par défaut des constantes entières est décimale (base 10), et peut être modifiée avec le préfixe 0x pour la base hexadécimale (base 16 ; ex : 0x1F0C) ou avec le préfixe 0 pour la base octale (base 8 ; ex : 0777).
  • Une constante numérique à virgule est considérée comme étant de type double. Il faut ajouter le suffixe F pour avoir une constante de type float. Il existe également un suffixe D pour double mais son utilisation est optionnelle.
  • String est le seul type non-primitif (donc absent du tableau) dont les instances possèdent une syntaxe littérale :
    "caractères..."
Types primitifs de Java
Type Taille Syntaxe Description Intervalle
char 2 octets
16 bits
'caractère' Une unité de code, suffisant à représenter un grand nombre de point de code, et même un caractère Unicode (UTF-16)
'b' '\u250C'
'\u0000' à '\uFFFF'
byte 1 octet
8 bits
Un nombre entier de 8 bits (soit un octet) signé -128 à 127
short 2 octets
16 bits
Un nombre entier de 16 bits signé entre −32 768 et +32 767 -32768 à 32767
int 4 octets
32 bits
[+|-]chiffres... Un nombre entier de 32 bits signé entre −2 147 483 648 et +2 147 483 647 -2147483648 à 2147483647
long 8 octets
64 bits
[+|-]chiffres...L Un nombre entier de 64 bits signé entre −9 223 372 036 854 776 000 et +9 223 372 036 854 776 000 -9223372036854775808L à 9223372036854775807L
float 4 octets
32 bits
[+|-][chiffres].[chiffres][E[+|-]chiffres]F Un nombre à virgule flottante de 32 bits signé (simple précision)
  • de (Float.MIN_VALUE) à (Float.MAX_VALUE),
  • 0.0F,
  • (Float.NEGATIVE_INFINITY),
  • (Float.POSITIVE_INFINITY),
  • pas un nombre (Float.NaN).
double 8 octets
64 bits
[+|-][chiffres].[chiffres][E[+|-]chiffres][D] Un nombre à virgule flottante de 64 bits signé (double précision)
  • de (Double.MIN_VALUE) à (Double.MAX_VALUE),
  • 0.0D,
  • (Double.NEGATIVE_INFINITY),
  • (Double.POSITIVE_INFINITY),
  • pas un nombre (Double.NaN).
boolean 1 octet false|true Une valeur logique false (faux) ou true (vrai)

Consultez également ces pages dans d’autres projets Wikimedia :

Ressources éducatives sur Wikiversité.


NombresModifier

Comme le montre le tableau précédent, Java possède différents types primitifs pour représenter les nombres. Ces types sont tous signés :

  • les nombres entiers sur 8 bits (byte), 16 bits (short), 32 bits (int) et 64 bits (long) ;
  • les nombres à virgule flottante sur 32 bits (float) et 64 bits (double) ;

excepté le type char utilisé pour représenté un point de code Unicode sur 16 bits qui peut aussi être utilisé comme type numérique non signé.

Pour aller au-delà de 64 bits, Java peut gérer des nombres de taille arbitraire, occupant plus de mémoire, via des types non primitifs.

BooléensModifier

Comme en Pascal, le langage Java a un type dédié aux résultats de l'évaluation de conditions ou expressions booléennes : le type boolean. Les deux valeurs possibles sont true (vrai) et false (faux).

boolean en_dehors_de_l_intervalle = (valeur < min) || (valeur > max);

if (en_dehors_de_l_intervalle)  // utilisation dans une condition if
{
    System.out.println("La valeur et en dehors de l'intervalle de validité.");
}

Ce type est particulièrement utile pour réutiliser le résultat d'une condition plusieurs fois, ou initialiser un état selon une condition.

Les opérateurs sur les booléens sont les suivants :

ou ||
Le résultat est vrai si l'un des deux opérandes est vrai, faux sinon.
et &&
Le résultat est vrai si les deux opérandes sont vrai, faux sinon.
non !
Le résultat est vrai si l'opérande est faux, et vice-versa.

Les deux opérandes binaires du et et du ou sont évalués de manière paresseuse (lazy evaluation) : le deuxième opérande n'est pas évalué si la valeur du premier suffit à déterminer le résultat final :

  • Pour le ou, si le premier opérande est true, le résultat est true.
  • Pour le et, si le premier opérande est false, le résultat est false.

Cela a de l'importance pour l'évaluation d'expression du deuxième opérande, notamment l'appel à une méthode ou l'accès à un membre d'un objet.

Exemple :

boolean non_vide = texte != null && texte.length() > 0;
// Si texte == null, la non évaluation du deuxième opérande empêche un déréférencement
// de la référence null et évite donc une exception de type NullPointerException.

 

Les valeurs booléennes peuvent aussi être utilisés avec les opérateurs sur les bits c'est-à-dire & et | qui évaluent systématiquement les deux opérandes.

boolean non_vide = texte != null & texte.length() > 0; // <!> Erreur d'opérateur
// Si texte == null, le deuxième opérande est tout de même évalué et un déréférencement
// de la référence null a lieu, provoquant une exception de type NullPointerException !

Pour effectuer un ou exclusif sur les booléens, il est possible d'utiliser l'opérateur de comparaison différent != ou l'opérateur ou exclusif sur les bits ^ qui dans les deux cas évaluent les deux opérandes.

 

La comparaison avec les valeurs true et false est inutile et peut apporter de la confusion.

if (non_vide == true) { ... }
if (non_vide == false == false) { ... }

Caractères pour char et StringModifier

Les caractères spéciaux suivants peuvent être utilisés pour les valeurs littérales des types char et String :

\r (ou \u000D)
Retour chariot (carriage Return),
\n (ou \u000A)
Nouvelle ligne (New line),
\f (ou \u000C)
Nouvelle page (Feed page),
\b (ou \u000C)
Retour arrière (Backspace),
\t (ou \u0009)
Tabulation (Tab),
\"
Guillemet (pour qu'il soit inclus au lieu de marquer la fin de la chaîne de caractères),
\'
Apostrophe (pour qu'il soit inclus au lieu de marquer la fin du caractère),
\OOO
Caractère 8 bits dont le code OOO est spécifié en octal (jusqu'à 3 chiffres),
\uXXXX
Caractère 16 bits (UTF-16) dont le code XXXX est spécifié en hexadécimal sur 4 chiffres exactement.
Cette séquence d'échappement peut également être utilisée en dehors des chaînes et caractères dans le code source :
\u0070ublic \u0063lass UneClasse ... /* <- public class UneClasse ... */
Cette fonctionnalité du langage est cependant à réserver au cas d'utilisation de code Java externe où les identificateurs de classe, attributs ou méthodes utilisent des caractères non supportés par le clavier du développeur (par exemple, des caractères Japonais).
String exemple = "Ce texte est la première ligne,\n\tsuivie d'une seconde ligne indentée par une tabulation.";

Variables et classesModifier

Les classes de base comme String ne sont pas des types primitifs. Il est aisé de les confondre mais les conventions habituelles d'écriture permettent de distinguer les deux types de données. Les types de variables primitifs sont toujours écrits en minuscules, par contre les noms des classes ont par convention leur premier caractère en majuscule. Aussi lorsque vous rencontrez un Boolean, ce n'est pas un type de base mais bien une classe. En effet les valeurs de type primitif peuvent être encapsulées, et Java fournit d'ailleurs pour tous les types primitifs des classes d'encapsulation appelées wrappers.

Ceci peut être utile dans certains cas pour bénéficier de certaines caractéristiques de leur classe mère Object. Par exemple, la pose d'un verrou de synchronisation (instruction synchronized) ne peut se faire que sur un objet.

Les emballages de types primitifsModifier

Une classe d'emballage (wrapper en anglais) permet d'englober une valeur d'un type primitif dans un objet. La valeur est stockée sous la forme d'un attribut. Chaque classe permet de manipuler la valeur à travers des méthodes (conversions, ...).

  • Character pour char
  • Byte pour byte
  • Short pour short
  • Long pour long
  • Integer pour int
  • Float pour float
  • Double pour double
  • Boolean pour boolean

Auto-boxingModifier

L'auto-boxing permet la conversion d'une valeur de type primitif en objet de la classe englobante correspondante de manière implicite, notamment lors d'une affection ou d'un passage d'arguments en paramètres d'une méthode.

Exemple :

public Integer somme(Integer a, Integer b)
{
	// <!> a et b sont de type objet et peuvent valoir null.
	// Dans ce cas, pour cette méthode, considérer que null vaut 0 :
	if (a==null) return b;
	if (b==null) return a;
	return a + b;
}

//...
System.out.println("Somme 1+2 = "+somme(1,2));
System.out.println("Somme  +2 = "+somme(null,2));


Pour plus de détails, voir la section Autoboxing du chapitre Transtypage de ce livre.

ConversionsModifier

Pour convertir une valeur du type indiqué par la ligne vers celui de la colonne :

Conversion vers Integer vers Float vers Double vers String vers Array vers Boolean
d'Integer - (float)x (double)x x.toString() new int[] {x}
de Float java.text.DecimalFormat("#").format(x) - (double)x
x.doubleValue()
x.toString()
Float.toString(x)
new float[] {x}
de Double java.text.DecimalFormat("#").format(x) java.text.DecimalFormat("#").format(x) - x.toString() new double[] {x}
de String Integer.parseInt(x) Float.parseFloat(x) Double.parseDouble(x) - new String[] {x} Boolean.valueOf(x)
de tableau x[0] x[0] x[0] Arrays.toString(x) -
de Boolean -