# Programmation Java/Types de base

* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
[ Modifier le sommaire ]
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 :

## 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 :
Il ne peut pas être placé avant le nombre, ou entre un chiffre et le point décimal ou le suffixe :

## 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).
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 :
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.
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.

## 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).

## 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 :
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 | | | | | | - |