Blog de Vincent Brabant : NetBeans, Java et autres

Un article de vbrabant    1 Commentaire

Pour vous préparer à la Certification Java SCJP 5.0, nous vous proposons quelques fiches.

Aujourd’hui, en voici une concernant les classes enveloppes

Les classes enveloppes

Nous avons fut dans la fiche précédente, qu’il y avait des types

Les classes enveloppes (Wrapper en anglais) sont les classes servant à envelopper ces fameux types de primitives. Ces classes enveloppes ne jouent pas que le rôle d’enveloppes. Elles jouent également le role de classes utilitaires car elle possèdent des méthodes permettant d’effectuer certaines opérations assez utiles.

Puisqu’il y a 9 primitives, vous trouverez également 9 classes enveloppes.
Voici un tableau avec à votre gauche la primitive et à droite la classe enveloppe correspondante.

byte     java.lang.Byte
short    java.lang.Short
char     java.lang.Character
int      java.lang.Integer
long     java.lang.Long
float    java.lang.Float
double   java.lang.Double

boolean  java.lang.Boolean

void     java.lang.Void

Il est intéressant de noter que les classes
Byte, Short, Integer, Long, Float et Double héritent toutes de la classe Number, mais pas la classe Character.
Ce qui tends bien à démontrer que le type de primitives char ne peut être entièrement rangé dans la catégorie des nombres, mais appartient également à la catégorie des caractères.

Classes enveloppes, mais également classes utilitaires

Comme nous le disions plus haut, les classes enveloppes font également office de classes utilitaires. Ainsi, toutes les classes enveloppes ont un membre statique TYPE qui retourne une instance de Class représentant le type de primitive correspondant.

Aussi

System.out.println(Integer.TYPE == int.class);

affiche

true

sur la console

les classes enveloppes pour les nombres (et également la classe Character) possèdent également des membres statiques MIN_VALUE et MAX_VALUE qui retourne les valeurs extremes qui peuvent être codées dans la taille qui lui est donnée, ainsi que SIZE qui retourne le taillé mémoire occupée par la primitive (le nombre de bits utilisés pour stoquer le nombre). Des classes comme Double, vous permet de vérifier qu’une valeur donnée est INFINI ou NaN (not a number).

Notez que SIZE fut introduit dans la version 5.0 de Java.

Voici un petit programme qui sert à afficher les valeurs extremes et la taille mémoire de la primitive pour le type correspondant. Attention que cela ne concerne que les classes enveloppes pour les nombres (ainsi que la classe Character).

public class Enveloppe{
    public static void main(String[] args) {
        //Les valeurs minimales
        Byte minByte = new Byte(Byte.MIN_VALUE);
        Short minShort = new Short(Short.MIN_VALUE);
        Character minCharacter = new Character(Character.MIN_VALUE);
        Integer minInteger = new Integer(Integer.MIN_VALUE);
        Long minLong = new Long(Long.MIN_VALUE);
        Float minFloat = new Float(Float.MIN_VALUE);
        Double minDouble = new Double(Double.MIN_VALUE);
         
        //Les valeurs maximales
        Byte maxByte = new Byte(Byte.MAX_VALUE);
        Short maxShort = new Short(Short.MAX_VALUE);
        Character maxCharacter = new Character(Character.MAX_VALUE);
        Integer maxInteger = new Integer(Integer.MAX_VALUE);
        Long maxLong = new Long(Long.MAX_VALUE);
        Float maxFloat = new Float(Float.MAX_VALUE);
        Double maxDouble = new Double(Double.MAX_VALUE);
         
        //Affiche taille, valeur minimale, et valeur maximale
        System.out.println(Byte.TYPE+" ("+Byte.SIZE+") : "+ minByte + " <-> "+maxByte);
        System.out.println(Short.TYPE+"("+Short.SIZE+") : "+ minShort + " <-> "+maxShort);
        System.out.println(Character.TYPE+"("+Character.SIZE+") : "+ (int) minCharacter + " <-> "+ (int) maxCharacter);
        System.out.println(Integer.TYPE+"("+Integer.SIZE+") : "+ minInteger + " <-> "+maxInteger);
        System.out.println(Long.TYPE+"("+Long.SIZE+") : "+ minLong + " <-> "+maxLong);
        System.out.println(Float.TYPE+"("+Float.SIZE+") : "+ minFloat + " <-> "+maxFloat);
        System.out.println(Double.TYPE+"("+Double.SIZE+") : "+ minDouble + " <-> "+maxDouble);
         
        System.out.println(minByte == Byte.MIN_VALUE);
        System.out.println(minShort == Short.MIN_VALUE);
        System.out.println(minCharacter == Character.MIN_VALUE);
        System.out.println(minInteger == Integer.MIN_VALUE);
        System.out.println(minLong == Long.MIN_VALUE);
        System.out.println(minFloat == Float.MIN_VALUE);
        System.out.println(minDouble == Double.MIN_VALUE);
        System.out.println(maxByte == Byte.MAX_VALUE);
        System.out.println(maxShort == Short.MAX_VALUE);
        System.out.println(maxCharacter == Character.MAX_VALUE);
        System.out.println(maxInteger == Integer.MAX_VALUE);
        System.out.println(maxLong == Long.MAX_VALUE);
        System.out.println(maxFloat == Float.MAX_VALUE);
        System.out.println(maxDouble == Double.MAX_VALUE);
         
        Double d = 1.0/0.0;
        Double d2 = -1.0/0.0;
        Double d3 = 0.0/0.0;
        System.out.println(d == Double.POSITIVE_INFINITY);
        System.out.println(d2 == Double.NEGATIVE_INFINITY);
        System.out.println(d3+" "+(d3 == Double.NaN));
        System.out.println(d3.isNaN());
    }
     
}

La classe Boolean
La classe Boolean possède également des membres statiques comme TRUE et FALSE, ainsi qu’une méthode valueOf() qui retourne toujours une référence aux mêmes objets référencés par TRUE et FALSE.

La classe Void
La classe Void est la classe la plus hors catégorie. En effet, c’est la seule classe enveloppe qui ne peut être instanciée et qui ne possède aucune méthode (exceptée celle héritée de la classe Object, bien évidemment) ni membre statique, excepté TYPE

La classe Character
C’est la classe contenant le plus de membres de toutes les classes enveloppes.
En effet, elle a des méthodes pour à peu près tout et n’importe quoi concernant les caractères.
Est ce que le caractère est une lettre? peut-il être utilisé dans un identifiant Java ? Est-ce une majuscule ? Quel est le caractère correspondant à sa minuscule ?
C’est la classe d’enveloppe qui a également connu le plus de modifications pour Java 5.

Mais aussi étrange que cela puisse paraître, la classe Character n’étend pas la classe Number.
Bizarre, vous avez dit bizarre. Comme c’est étrange.
Je n’ai aucune explication permettant d’expliquer pourquoi la classe Character n’hérite pas de la classe Number. Notez également que la classe Number ne possède pas de méthode charValue(), ce qui temd à prouver que char n’est pas vraiment à classifier dans les types de primitives numériques. Mais alors, pourquoi avoir fait le travail à moitier puisqu’on peut additionner des char entre eux aussi facilement ?

Si quelqu’un pouvait me donner la raison, j’en serais ravi. C’est juste par curiosité.