5. Classes enveloppe

5.1. Associer les types de base à des objets

Les classes enveloppe (appelées en anglais classes wrapper ) sont associées à chacun des type de base. Aux types de base boolean, byte, short, char, int, long, float et double, sont donc associées des classes Boolean, Byte, Short, Character, Integer, Long, Float et Double. Ces classes sont construites sur le même modèle. Elles ont toutes un constructeur qui correspond au type de base qu’elle représente. Par exemple, pour la classe Integer :

Exemple 75. Construction d'un Integer

public Integer(int i) ;

Ensuite, les classes qui représentent des nombres étendent la classe Number, qui propose des méthodes byteValue(), shortValue(), intValue(), longValue(), floatValue() et doubleValue(). Ces méthodes permettent de convertir la valeur numérique portée par l’objet en un type de base explicite. Enfin, ces classes possèdent une méthode statique, parse[TypeDeBase](String s), qui permet de décoder la chaîne de caractères passée en argument. Par exemple, si l’on veut lire un nombre flottant en double précision dans une chaîne de caractères, il suffit d’écrire les lignes suivantes.

Exemple 76. Conversion d'une chaîne de caractères en nombre

String s =  "1.2563556e-3" ;  
 double d = Double.parseDouble(s) ;  
Double dObjet = Double.valueOf(s) ;

Notons que ces appels peuvent générer une exception : NumberFormatException. Les classes wrapper possèdent une méthode toString() prenant en paramètre le type wrappé, par exemple Integer.toString(int). Cette méthode statique permet de convertir un nombre en chaîne de caractères de façon très efficace. Une façon communément utilisée pour faire cette conversion est d'écrire :

Exemple 77. Conversion d'un nombre en chaîne de caractères - 1

int i =  12345 ;  
String s =  "" + i ;

Cette méthode fonctionne, mais, elle est assez peu élégante et il faut éviter de l'utiliser. Il est vrai que la notion d'élégance en programmation est un argument plus que douteux, la plupart du temps utilisé pour tenter de rallier tout de même quelqu'un à son opinion lorsque l'on est à bout d'arguments réels... Disons simplement que la conversion suivante est environ 3 fois plus performante que le pattern précédent, cet argument est nettement meilleur.

Exemple 78. Conversion d'un nombre en chaîne de caractères - 2

int i =  12345 ;  
String s = Integer.toString(i) ;

Ce second argument est beaucoup plus percutant ! Tout comme la classe String, les classes enveloppes sont finales : elles ne peuvent pas être étendues. De plus, la valeur portée par un objet wrapper ne peut pas être modifiée une fois l'objet construit. Ce sont donc des objets immutables. Ce point est très important, car il permet de conserver la cohérence du passage de paramètre par valeur. Observons le cas suivant.

Exemple 79. Importance de l'immutabilité des classes wrapper

public  class Main {  
  
     public  static  void incremente(int i) {  
        i++ ;  
    }  
      
     public  static  void main(String[] args) {  
         int i =  1 ;  
        incremente(i) ;  
        System.out.println("i = " + i) ;  
    }  
}

Le résultat est bien sûr le suivant :

 > i = 1

Effectivement, la méthode incrémente(int) ne possède que la valeur du paramètre. Modifier cette valeur n'a donc pas d'influence sur celle possédée par la méthode main(). Imaginons que l'on réécrive cet exemple simple avec des Integer au lieu d' int. S'il était possible de changer la valeur numérique portée par l'objet de type Integer, alors il serait possible à la méthode incremente(Integer) d'effectivement incrémenter l'objet passé en paramètre. La classe Integer étant immutable, ce n'est pas le cas, et le contrat du passage par valeur est toujours respecté.

5.2. Auto-boxing

L'un des apports de Java 5 dans ce domaine est la notion d'auto-boxing, et d'auto-unboxing. En Java 4, on ne peut constuire un objet wrapper qu'explicitement, par appel à son constructeur ou à une de ses méthodes. En Java 5, il es possible d'écrire ce genre de choses :

Exemple 80. Auto-boxing et auto-unboxing

Integer i =  new Integer(1) ;  // instanciation classique d'un Integer  
Integer j =  1 ;               // conversion automatatique -> boxing  
 int k = i ;                   // conversion automatique -> unboxing

Ces deux opérations sont effectuées lors de la compilation. C'est à la compilation que le code nécessaire à ces conversions est ajouté, puis compilé. On ne gagne donc rien en performance lors de l'exécution : l'auto-boxing n'est qu'une facilité d'écriture. On se méfiera lors de la conversion d'un objet wrapper en type de base : si cet objet est null, alors l'infâme NullPointerException sera jetée.

Java langage & API

Retour au blog Java le soir

Cours & Tutoriaux