Les types primitifs et les classes enveloppes

Date de publication : 15/06/2006

Par Anis Frikha (Mon site)
 

I. Introduction

II. Les types primitifs

II-A. Les types primitifs entiers

• 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.

• 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.

• Inverser tous les bits dans la representaion 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.

• a=33; c'est la manière classique de faire, on utilise une notation décimale
• a=0x21; on utilise une notation héxadécimale, pour cela on fait préceder la valeur en héxadécimal par 0x
• a=041; on utilise ici une notation octale, pour cela on fait précédé 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.

II-B. Les types primitifs flottants

Seuls les entiers et les rationnels dont le dénominateur est une puissance de 2 peuvent être représentés exactement.Si vous avez besoin d'une grande précision lors de vos calculs, je vous conseille de recourir à la classe BigDecimal

Que ce soit pour les entiers ou pour les flottants, il n'est pas nécessaire de connaître par coeur leurs valeurs limites, par contre il est important d'avoir une idée sur leur ordre de grandeur car les dépassements de capacité ne sont jamais signalés et ce quelque soit le language.

• 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 equivalent à b=4.25e4 c'est la notation exponentielle ou scientifique.

II-C. Le type primitif caractère

Le type char est le seul à n'accepter que des valeures entières positives

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

II-D. Le type primitif booléen

boolean test=(5==3);

II-E. Le type primitif void

II-F. Emploi des types primitifs

• Un entier de type int
• Le code Unicode d'un caractère

Bien que le type short a une taille de 2 octets, on ne peut pas affecter, sans cast, un char à un short. Il en va de mème pour le type byte.A noter que les conversions sans perte de précision (et donc sans cast) sont tout à fait possibles du moment que l'on respecte l'ordre de grandeur des types : byte < char|short < int < long < float < double

• 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

III. Les classes enveloppes

III-A. Les classes enveloppes numériques

• Les méthodes byteValue(), shortValue(), intValue(), longValue(), floatValue() et doubleValue() : Ces méthodes,présentes dans toutes les classes numériques (car héritées de la super classe Number), renvoient le type primitif indiqué. Elles constituent donc un pont entre les objets et les types primitifs.
  
• Les méthodes statiques parseByte(String), parseShort(String), parseInt(String), ...:qui renvoient le type primitif correspondant. Attention ces méthodes peuvent générer une exception du type NumberFormatException et doivent donc étre placées dans un bloc try/catch.
  
• Les méthodes statiques valueOf(String) qui renvoient elles en revanche un objet. Par exemple Integer.valueOf("4"); renverra un objet de type Integer ayant pour valeur 4.
  

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");
		}
	}
}

• 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.

À noter que toutes ces classes,en plus de la classe Character, possédent des attributs MIN_VALUE et MAX_VALUE representant les valeurs limites pour chaque type,ainsi qu'un attribut SIZE indiquant le nombre de bits nécessaires afin de représenter le nombre.

III-B. La classe enveloppe Character

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 miniscule, de retrouver le code Unicode du caractère,...Une consultation de la  javadoc vous donnera une vue exhaustive des capacités de cette classe.

Character n'héritant pas de Number ne dispose pas de méthodes telles que charValue ou parseChar

III-C. La classe enveloppe Boolean

Bien que cette classe ne présente pas un intêret majeur, il est tout de mème utile de connaitre son existance et d'avoir regarder la page  javadoc la concernant au moins une fois ;)

IV. Récapitulatif

toutes ces classes redéfinissent la méthode toString() héritée de Object afin qu'elle renvoie le type primitif en question sous forme de chaine de caractère.

les classes enveloppes sont immuables, et toutes modifications de la valeur aboutissent à un nouvel objet.

V. Nouveautés Java 5

int a=6;
Integer b=new Integer(0);
b=a;

a=b;

Integer integer = 0;

Integer integer = Integer.valueOf(0);

int a = integer;

int a = integer.intValue();

• decode("012") retourne 10, car la chaine commence par 0, elle donc bien écrite en base 8
• decode("0x12") retourne 18, car la chaine est lue en base 16 à cause du 0x
• decode("12") retourne bien sùr 12 car la chaine est déjà en base 10

VI. Conclusion

VI. Remerciement

VIII. Liens utiles

• L'incontournable  javadoc
• Un  article fort intéressant sur la réprésentation du type double en mémoire
• Un  article fait maison sur l'autoboxing.