Programmation Java/Types de base

Commentaires

Opérateurs

Programmation Java

Version imprimable

[ Modifier le sommaire ]

Commentaires

Opérateurs

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 $2^{-149}$ (`Float.MIN_VALUE`) à $2^{128}-2^{104}$ (`Float.MAX_VALUE`), `0.0F`, $-\infty$ (`Float.NEGATIVE_INFINITY`), $+\infty$ (`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 $2^{-1074}$ (`Double.MIN_VALUE`) à $2^{1024}-2^{971}$ (`Double.MAX_VALUE`), `0.0D`, $-\infty$ (`Double.NEGATIVE_INFINITY`), $+\infty$ (`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é.

Nombres

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.

Depuis Java 7, le caractère souligné peut être utilisé pour séparer les chiffres (et uniquement les chiffres) afin de les regrouper.

Exemple :

long isbn = 978_2_416_00018_8L; // Suffixe L pour un nombre de type long
double pi = 3.14__159__26;

Il ne peut pas être placé avant le nombre, ou entre un chiffre et le point décimal ou le suffixe :

// Erreurs de compilation :
long isbn = _978_2_416_00018_8_L;
double pi = _3._14__159__26_;

Booléens

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 `String`

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 classes

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 primitifs

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-boxing

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.

Conversions

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						-

Nombres

Booléens

Caractères pour char et String

Variables et classes

Les emballages de types primitifs

Auto-boxing

Conversions

Caractères pour `char` et `String`