Les différents types de données en Java

En Java, il existe deux catégories de types de données : les types primitifs et les types références( en Java, les objets sont manipulés par références).

Les types primitifs

Il existe huit types primitifs prédéfinis en Java :

• Six types numérique : quatre types d'entiers signés (byte, short, int et long) et deux types réels à virgule flottante (float et double);
• Le type caractère char utilisé pour représenter des caractères Unicode;
• Le type boolean : représente les valeurs booléennes false et true.

Ces types appelés types primitifs, car les variables de ces types ne sont pas stockées sous la forme des objets, ce qui permet une utilisation plus efficace. Ces types de données ont la même taille quelque soit la plate-forme et le système d'exploitation utilisé.

Il faut noter que le package java.lang inclut des classes correspondant à chacun de ces types primitifs. A la différence des types primitifs, ces classes permettent de définir des objets.

1. Les types primitifs numériques

Le tableau suivant donne tous les types numériques de base qu'il est possible de former :

Les classes du package java.lang correspondant à ces types primitifs sont Byte , Short, Integer, Long, Float et Double. Il faut noter que les noms des classes commencent toujours par une lettre en majuscule, alors que les noms des types primitifs ne s'écrivent qu'en minuscule.

• Pour définir une constante entière en hexadécimal, il faut la fair précéder par 0x ou 0X (exemple: 0xCAF9)
• Une constante entière est par défaut de types int. pour définir une constante entière de types long, il faut la faire suivre par la lettre l ou L (exemple: 4000000000L)
• Une constante décimale doit comporter un . (point) ou un e (ou E : exposant). Par défaut, cette constante est de type double. Pour définir une constante décimale de type float, il faut la faire suivre par la lettre f ou F (exemple: 3.402f).

       2. Le type primitif char

En Java , le type caractère char est implémenté sur 16 bits (2 octets) pour représente l'ensemble des caractères Unicode.

 L'unicode est un système qui comporte les caractères de toutes les langues écrites. Les caractères du code ASCII sont contenus dans l'Unicode. Pour plus d'informations sur le standard Unicode, visitez le site web Unicode à l'adresse : http://www.unicode.org.

Une constante de type char est :

• Un caractère unique placé entre deux guillemets : 'A', '+', '3', ...etc.
• Une suite de deux caractères, le premier est \ (anti-slash ou back-slash) pour désigner les caractères spéciaux (caractères de contrôle non imprimable) : '\b' (retour arrière : Backspace), '\n' (nouvelle ligne: Newline), '\t' (tabulation horizontale), ... etc.
•  De la forme '\unnnn' : pour désigner un caractère Unicode. nnnn est le code du caractère formé de 4 chiffres hexadécimaux (en base 16). L'interface de ces valeurs va de '\u0000' à '\uFFFF' : '\u00ff' , '\u000b', ... etc.
• La classe du package java.lang qui correspond à ce type primitif est Character.
• Le type char est non signé et peut être converti explicitement par une opération de transtypage (cast) en type numérique (de byte à double).

      3. Le type primitif boolean

 Le type boolean sert à définir des variables qui peuvent contenir soit la valeur false, soit la valeur true. En Java , la conversion est interdite entre les booléens et les nombres, même par transtypage, la classe du package java.lang qui correspond à ce type primitif est Boolean.

Les Types références 

En Java, les objets utilisés dans un programme ne sont pas manipulés directement, en effet, on ne peut manipuler que des références (pointeurs implicites) à ces objets. C'est pourquoi, on parle de type référence. Les emplacements mémoires réservés à ces objets sont alloués dynamiquement à l'aide de l'opérateur new.

Il y a trois catégories de types références : les classes, les interfaces et les tableaux. Un objet est soit une instance de classe, soit un tableau (qui  est en fait une instance de la classe Array qui se trouve dans le package java.lang.reflect).

Les  interfaces ne peuvent pas être instanciées, ce qui signifie qu'il est possible d'avoir une réérebce de type interface mais pas d'objets de type interface.