Les types primitifs et les classes enveloppes

Les types entiers servent à représenter des entiers relatifs : il s'agit des types byte, short, int, et long, dont voici un tableau récapitulant leurs tailles, leurs maximums et minimums :

Intéressons-nous à présent à la représentation en mémoire de ces types. Pour cela, on doit faire la distinction entre les nombres positifs et négatifs. En effet, un nombre positif est codé de la manière suivante :

• le bit de poids fort est appelé le bit de signe et il a la valeur 0 ;
• les autres bits représentent la valeur absolue du nombre codé en base 2.

Pour les nombres négatifs en revanche, la représentation est comme suit :

• le bit de poids fort qui est le bit de signe vaut 1.
• la valeur absolue du nombre est codée par la technique du complément à deux.

Mais qu'est-ce que la technique du complément à deux ?

La technique du complément à deux consiste à :

• inverser tous les bits dans la représentation binaire de la valeur absolue du nombre : c'est-à-dire remplacer tous les 0 par des 1 et les 1 par des 0 ;
• ajouter 1 au nombre obtenu.

Avec cette technique, additionner/soustraire deux nombres entiers relatifs se résume à additionner bit à bit. Cette opération nécessite donc très peu de circuits logiques au sein de l'UALUnité Arithmétique et Logique. Il en résulte des calculs très rapides.

Voici un petit exemple pour assimiler la chose. On s'intéresse à l'opération : 45 - 63, ce qui est équivalent à 45 + (-63) et on supposera que ces nombres sont des bytes donc codés sur un seul octet. La représentation binaire de 45 est : 00101101. Pour la représentation binaire de -63, on adopte la démarche suivante :

Il nous reste plus maintenant qu'à faire l'addition bit à bit :

Comme le résultat de cette addition est un nombre négatif, il sera sous la forme « complément à deux », ce qui est fort pratique pour le processeur afin de réaliser des opérations successives. Et voilà, c'est magique, non ?

Intéressons-nous maintenant aux règles de conversion. Il est bien entendu possible de convertir une valeur codée dans un type donné vers un type de plus grande capacité et ceci sans perte de précision. On peut imaginer la conversion comme ceci : byte → short → int → long

On peut affecter une valeur entière à une variable de différentes façons : supposons que a soit de type int et qu'on veuille lui affecter la valeur 33, on peut procéder comme suit :

• a = 33; c'est la manière classique de faire, on utilise une notation décimale ;
• a = 0x21; on utilise une notation hexadécimale, pour cela on fait précéder la valeur en hexadécimal par 0x ;
• a = 041; on utilise ici une notation octale, pour cela on fait précéder la valeur en octal par 0 ;
• a = 33L ici on force 21 à être de type long en la faisant suivre d'un l ou L. Notez que pour des raisons de visibilité il vaut mieux utiliser une majuscule.

Il existe en Java deux types primitifs permettant de représenter des nombres flottants, à savoir float et double, dont voici les valeurs limites :

Si l'on exécute l'opération 0.3 - (3 * 0.1) le résultat ne sera pas nul ! Une petite explication s'impose. En fait, la raison réside dans la représentation en mémoire des nombres flottants de type double : elle est composée d'un bit de signe, de la mantisse sur 52 bits et de l'exposant sur 11 bits. Pour le type float, il est représenté par un bit de signe, une mantisse sur 23 bits et un exposant sur 8 bits.

Le nombre est alors représenté sous la forme d'un rationnel approchant au maximum le réel entré.

Il existe différentes façons d'affecter une valeur à une variable flottante. Supposons que a et b soient respectivement de type float et double. Les affectations suivantes sont correctes :

• a = 15f le f est obligatoire pour signaler que c'est un float ;
• b = 0.12 c'est la notation décimale ;
• b = 4.25E4 qui est équivalent à b = 4.25e4 c'est la notation exponentielle ou scientifique.

Note : on peut forcer une valeur à être de type double en faisant suivre sa valeur par la lettre D ou d.

Le type caractère en Java est représenté par char qui est codé, non pas sur un octet comme la plupart des autres langages, mais sur deux octets afin de supporter l'Unicode. Outre les caractères qu'on peut saisir au clavier, on peut entrer d'autres caractères non disponibles sur le clavier en passant par le code Unicode en hexadécimal du caractère et ceci avec la syntaxe suivante \uxxxx où xxxx représente le code. Par exemple le caractère pi a pour code 03C0.

Le type char est un peu particulier dans la mesure où on peut affecter une valeur entière positive à une variable de type char.

L'exemple de code suivant permet d'afficher le symbole PI :

public class TestChar {
    public static void main(String args[]) {
        char c=1055;
        System.out.println(c);
    }
}

Le type char pouvant accepter des valeurs numériques, il possède lui aussi une capacité et des limites représentées par le tableau ci-dessous.

Contrairement à d'autres langages, Java dispose d'un type booléen, il s'agit de boolean. On peut par exemple affecter le résultat d'un test à une variable de type boolean ainsi l'expression :

boolean test = (5==3);

a un sens.

Une variable de type boolean ne peut prendre que deux valeurs à savoir : true et false.

Ce type n'a pas d'intérêt majeur mis à part le fait qu'il permet de signaler qu'une méthode ne renvoie rien.

Java, comme la plupart des autres langages de programmation, dispose d'opérateurs arithmétiques binaires, c'est-à-dire portant sur deux opérandes. Ces opérateurs sont : + (addition), - (soustraction), * (multiplication), / (division) , et enfin % (modulo). Ces opérateurs ne sont pas définis pour les types byte, short et char, pourtant il est possible d'utiliser des variables de ces types dans des expressions arithmétiques grâce à la promotion numérique.

La promotion numérique consiste à changer ces types non définis en int. Par exemple :

On peut aussi s'interroger sur le fonctionnement de ces opérateurs lorsque les opérandes ne sont pas de même type. En fait, dans ce cas, on a affaire à ce qu'on appelle les conversions d'ajustement de type. Java procède à un changement du type des opérandes afin qu'ils soient tous de même type pour pouvoir calculer l'expression. Ce changement de type se fait de telle sorte qu'il n'y ait pas de perte de précision, c'est-à-dire suivant la hiérarchie suivante : int->long->float->double.

Considérons l'exemple suivant :

En Java, on peut faire intervenir des variables de type char dans une expression arithmétique grâce à la promotion numérique en int. Ceci est possible, car une variable de type char n'est qu'une suite de bits en mémoire qui peut être vue comme :

• un entier de type int ;
• le code Unicode d'un caractère.

Ainsi une expression du type a + b où a et b sont de type char aura pour résultat un int. Et la conversion char vers int est tout à fait licite : si i est de type int et j de type char, faire i = j est correct.

Si on désire « casser » la chaîne de conversion, c'est-à-dire changer de sens, la seule manière d'y arriver est de faire un cast. Attention à la perte de précision ! Par exemple, avec a un short et b un int, on peut faire a = (short)b. Si b est trop grand pour tenir sur 2 octets (qui est la taille de short) alors les bits en trop seront perdus.

Les classes Double et Float possèdent quelques attributs statiques intéressants qui sont : POSITIVE_INFINITY, NEGATIVE_INFINITY et NaN (Not a Number). Voici quelques cas d'utilisation :

• 1 + Double.POSITIVE_INFINITY renvoie POSITIVE_INFINITY ;
• Double.POSITIVE_INFINITY + Double.POSITIVE_INFINITY renvoie aussi POSITIVE_INFINITY ;
• 12/0 renvoie Double.POSITIVE_INFINITY ;
• 0/0 renvoie Double.NaN ;
• Double.POSITIVE_INFINITY+Double.NEGATIVE_INFINITY renvoie Double.NaN.

Les classes enveloppes numériques dérivent toutes de la classe Number et elles sont : Byte, Short, Integer , Long, Float et enfin Double.

Toutes ces classes admettent un constructeur ayant pour paramètre le type primitif correspondant. Par exemple pour obtenir un objet Integer à partir d'un int de valeur 2 il suffit de faire : Integer objetEntier = new Integer(2).

Ces classes présentent diverses méthodes semblables dont voici une présentation des plus utilisées à mon avis :

Voici des exemples de code illustrant l'emploi ces méthodes.

La méthode parseInt(String) :

public class Parse {
    public static void main(String args[]) {
        String nbreChaine="455";
        int vraiNbre;
        try {
            vraiNbre=Integer.parseInt(nbreChaine);
        } catch(NumberFormatException e) {
            System.out.println("nbreChaine n'est pas un vrai nombre");
        }
    }
}

La méthode parseInt(String, int) où int représente la base de la chaîne en argument :

• parseInt("473", 10) retourne 473, car on considère la chaîne comme étant codée en base 10 ;
• parseInt("-FF", 16) retourne -255 ici on emploie la base 16 ;
• parseInt("1100110", 2) retourne 102, car la chaîne est codée en base 2.

Les méthodes valueOf(String, int) ont le même comportement que les parseXxx(String, int) sauf qu'elles retournent des objets et non des types primitifs.

Si aucune base n'est spécifiée, c'est-à-dire qu'on utilise les méthodes parse ou valueOf à un seul paramètre, la base par défaut sera la base 10. Ainsi parseInt("473", 10) sera équivalent à parseInt("473").

Cette classe sert comme vous vous en doutez à encapsuler un char. Elle dispose d'un grand nombre de méthodes permettant de savoir si c'est une majuscule ou une minuscule, de retrouver le code Unicode du caractère, etc. Une consultation de la Javadoc vous donnera une vue exhaustive des capacités de cette classe.

Bien que cette classe ne présente pas un intérêt majeur, il est tout de même utile de connaître son existence et d'avoir regarder la page Javadoc la concernant au moins une fois ;).