Rechercher
 

Les autres types de données en Java

Les chaînes de caractères Les opérateurs



Accès rapide :
   Les classes enveloppantes (Wrapped Classes)
   Les tableaux
   Les types énumérés

Les classes enveloppantes (Wrapped Classes)

Java est un langage totalement objet : il en résulte que la notion de fonction n'existe pas en tant que telle. A la place, Java vous propose de coder des méthodes (statique ou non) : une méthode étant, en quelques sorte, une fonction, mais obligatoirement portée par une classe. Il n'existe donc pas, en Java, de fonctions travaillant sur les types primitifs, comme cela peut être le cas en C : à titre d'exemple le langage C fournit la fonction atoi (Ascii TO Integer) pour transformer une chaîne en un nombre entier. A la place il va nous falloir trouver des méthodes.

A l'instar de la classe java.lang.String (cette notation indique que l'on parle de la classe String localisée dans le package java.lang, le package java.lang propose d'autres classes associées au types primitifs : on parle de classes enveloppante (ou de Wrapped Classes en anglais). Il existe une classe enveloppante par type primitif : chacune d'elle proposant un ensemble de méthodes permettant divers traitements relatifs au type primitif associé. L'exemple ci-dessous vous montre comment transformer une chaîne de caractères en une valeur numérique (pour peu que la chaîne contienne bien un texte équivalent à une valeur numérique).

 
01 public class TestWrapper  {
02 
03     public static void main( String [] args ) {
04         
05         String strFirstValue  = "10";
06         String strSecondValue = "11";
07         
08         // Doit afficher la chaîne 1011 (concaténation)
09         System.out.println( strFirstValue + strSecondValue );
10 
11         int iFirstValue = Integer.parseInt( strFirstValue );
12         int iSecondValue = Integer.parseInt( strSecondValue );
13         
14         // Doit afficher la valeur entière 21
15         System.out.println( iFirstValue + iSecondValue );
16         
17     }
18 
19 }

Le tableau ci dessous, associe pour chaque type primitif sa classe enveloppante.

Classe enveloppante Type primitif associé
java.lang.Byte byte
java.lang.Short short
java.lang.Integer int
java.lang.Long long
java.lang.Float float
java.lang.Double double
java.lang.Boolean boolean
java.lang.Character character

Les tableaux

Bien entendu, Java permet lui aussi d'utiliser les tableaux. Un tableau est un ensemble d'éléments d'un même type : par exemple, un tableau d'entiers, un tableau de chaînes de caractères, ... En fait, depuis notre premier exemple de code Java, nous avions introduit le concept de tableau. Effectivement, tout programme Java peut être lancé à partir de la ligne de commande et peut donc accepter un certain nombre d'arguments. La méthode statique main prend en paramètre en tableau de chaînes de caractères appelé args : il correspond à l'ensemble des arguments fournis sur la ligne de commande.

Pour introduire une variable de type tableau il vous faut utiliser la syntaxe []. Néanmoins les crochets peuvent être placés à différents endroits. Le tableau ci-dessus vous propose quelques exemples de définition de tableaux Java. Pour information, un tableau (tout comme les objets et en fait un tableau est un objet en Java) est référencé par un pointeur : à défaut d'initialisation, le tableau aura la valeur null et devra être initialisé ultérieurement. L'initialisation d'un tableau s'effectue obligatoirement via l'opérateur new (nous y reviendrons dans le chapitre suivant).

Définition de tableau Explications complémentaires
int [] tb; Définit un tableau d'entiers non encore initialisé.
int [] tb = new int[10]; Définit un tableau de dix entiers. Il n'est plus possible de changer la taille de ce tableau.
int [] tb1, tb2; Comme les crochets sont placés à gauche des noms de variables ils s'appliquent à toutes ces variables. On est donc en train de définir deux tableaux d'entiers, tous deux non initialisés.
int [] tb1 = new int[5], tb2 = new int[10]; Définit un premier tableau de cinq entiers, puis un second de dix entiers.
int tb[] = new int[10], value = 10; Définit un tableau de dix entiers ainsi qu'une variable (value) de type entier. Les crochets ne s'appliquent uniquement qu'à tb car ils sont placés à la droite du nom de la variable.
String [] strValues = new String[5]; Définit un tableau pouvant contenir jusqu'à cinq chaînes de caractères.
String [] strValues = { "toto", "titi", "tata" }; Définit un tableau de chaînes de caractères contenant les trois valeurs stockées entre les accolades.

Il est possible de connaître la taille d'un tableau à n'importe quel moment. Pour ce faire il faut demander au tableau la valeur de son attribut length (la notion d'attribut sera présentée plus sérieusement dans les chapitres relatifs à la programmation orientée objet). Les développeurs C et C++ noteront une différence importante entre les tableaux Java et les tableaux C/C++ : effectivement, en C et en C++, il est impossible de demander à un tableau quelle est sa taille. C'est le développeur C++ qui doit garantir la cohérence des accès aux tableaux : cet aspect est souvent une source de bug importante. Du coup, si votre programme Java cherche à accéder à un indice incohérent, le système Java s'en aperçoit et une erreur est déclenchée (via le mécanisme d'exception - nous y reviendrons plus tard).

Le programme ci-dessous vous permettra de vous familiariser avec l'utilisation des tableaux. Il est constitué de deux parties. La première affiche la liste des arguments du programme qui auront étaient fournis sur la ligne de commande (lancez le programme à partir de la console ainsi : java TestArrays arg1 arg2 suite). La seconde partie créer un tableau contenant les carrés des valeurs comprises entre 0 et 9 puis affiche ces valeurs.

 
01 public class TestArrays  {
02 
03     public static void main( String [] args ) {
04         
05         // On affiche les arguments de la ligne de commande (s'il y en a).
06         int arrayLength = args.length;
07         
08         if ( arrayLength > 0 ) {
09             System.out.println( "Voici la liste des arguments de la commande" );
10             for( int index=0; index<arrayLength; index++ ) {
11                 System.out.println( args[index] );
12             }
13         }
14         
15         // On créer et on affiche un tableau des
16         // dix premières valeurs entières élevées au carré
17         int [] squareArray = new int[10];
18         
19         for( int value=0; value<10; value++ ) {
20             int square = value * value;
21             squareArray[ value ] = square;
22         }
23         
24         for( int value=0; value<10; value++ ) {
25             System.out.println( value + "² == " + squareArray[value] );
26         }
27     }
28 
29 }

Les types énumérés

En premier lieu, il faut savoir une chose importante : les types énumérés en Java n'existent pas depuis les premières versions du langage : ils sont arrivés avec la version Java SE 5.0. Avant les développeurs Java se débrouillez avec des constantes entières pour palier à ce manque. Du coup, y compris au sein de la librairie Java, on aurait pu envisager à de multiples endroits l'utilisation de ces types, mais il en est rien. De plus, pour de histoire de comptabilité du code, il n'y a pas eut de modifications de la librairie sur ces points.

Un type énuméré ressemble, d'un certain point de vue, au type booléen de par le fait qu'il accepte un nombre d'état restreint. Néanmoins, avec un type énuméré, c'est vous qui choisissez les états acceptés par le type. Voici un petit exemple d'utilisation d'un type énuméré. ATTENTION : ici, le énuméré est définit dans le même fichier que la classe de démarrage (afin de simplifier d'exemple), mais du coup le type (considéré comme privé au fichier) ne peut être utilisé que et uniquement que dans ce fichier. Si vous souhaité exploiter ce type de par ailleurs, placez la définition de ce type dans un fichier FeuCroisement.java et rajoutez le mot clé public devant la définition du type (je rappelle que le type public exposé par un fichier de code Java, doit avoir exactement le même nom que le fichier).

 
01 enum FeuCroisement {
02     VERT, ORANGE, ROUGE
03 }
04 
05 
06 public class TestEnum  {
07 
08     
09     public static void main( String [] args ) {
10         
11         FeuCroisement feu = FeuCroisement.VERT;
12         
13         if ( feu == FeuCroisement.ROUGE ) {
14             System.out.println( "Stop, le feu est rouge" );
15         } else {
16             System.out.println( "Le feu n'est pas rouge" );
17         }
18         
19     }
20 
21 }

Pour ceux qui sont déjà familiarisés avec la programmation orientée objet, sachez qu'en réalité un type énuméré est une classe dérivant du type java.lang.Enum et que ses états son des attributs statiques constants. Du coup il est possible d'enrichir un type énuméré de différentes manières (ajout de constructeurs, ajout de méthodes, ajout d'attributs, ...). A titre d'exemple, voici un dernier exemple qui montre comment, en Java, mettre en relation un état du type énuméré avec une valeur numérique. ATTENTION : effectivement, si vous êtes développeur C ou C++, sachez que les types énumérés Java ne se comportent pas de la même manière que dans ces langages. Effectivement, un type énuméré n'est plus un sous ensemble du type int. Il n'est donc plus possible (même par cast) de faire correspondre simplement l'un des états proposé dans l'exemple ci-dessus avec une valeur entière. La manipulation proposée ci-dessous est donc obligatoire en Java pour obtenir le mapping.

 
01 enum FeuCroisement {
02     
03     // La définition de nos trois états.
04     VERT(0), ORANGE(1), ROUGE(2);
05 
06     // Un attribut privé.
07     private final int value;
08 
09     // Un constructeur d'état pour le type énuméré
10     // Forcément private !!!
11     private FeuCroisement(int value) {
12         this.value = value;
13     }
14 
15     // Une méthode permettant de retrouver la valeur
16     // numérique associée.
17     public int getValue() {
18         return this.value;
19     }
20 }
21 
22 public class TestEnum  {
23 
24     
25     public static void main( String [] args ) {
26         
27         FeuCroisement feu = FeuCroisement.VERT;
28         System.out.println( feu.getValue() + "\n" );
29 
30         for( FeuCroisement currentValue : FeuCroisement.values()) {
31             int numericValue = currentValue.getValue();
32             System.out.println( currentValue + " == " + numericValue );
33         }
34         
35     }
36 
37 }


Les chaînes de caractères Les opérateurs