Il arrive souvent que l'on doive convertir une chaine de caractères en nombre. Nous allons revoir comment effectuer cette conversion en utilisant les classes Integer et Double du package java.lang. La chaine de caractères à convertir étant souvent fournie par un utilisateur, des erreurs qui rendent la conversion impossible peuvent se produire. Nous verrons donc aussi comment gérer ses erreurs à l'aide des exceptions.
Nous avons déjà largement utilisé les types int et double. Java fournit des classes Integer et Double qui permettent de traiter les nombres comme des objets. Ces classes permettent de convertir simplement des chaines de caractères en nombre.
Les classes Integer et Double possèdent un constructeur qui utilise une chaine de caractères en paramètre. Elles disposent aussi de méthodes intValue et doubleValue qui renvoient des valeurs de type int et double. En combinant ces deux idées on peut facilement transformer une chaine de caractères en nombre.
Par exemple, pour convertir une chaine S en un entier i, on écrira:
Integer I=new Integer(S); int i=I.intValue();
Attention, la variable I est un objet de type Integer alors que la variable i est un entier.
De même, pour convertir une chaine S en un nombre à virgule d, on écrira:
Double D=new Double(S); double d=D.doubleValue();
Ici aussi on a une variable D qui est un objet de type Double et une variable d qui est un nombre décimal.
Les classes Integer et Double possèdent la méthode statique valueOf qui transforme une chaine de caractères en un objet. En faisant appel aux méthodes intValue ou doubleValue de cet objet on obtient un résultat sous forme de nombre.
Par exemple, pour convertir une chaine S en un entier i, on écrira:
int i=Integer.valueOf(S).intValue();
De même, pour convertir une chaine S en un nombre à virgule d, on écrira:
double d=Double.valueOf(S).doubleValue();
Java fournit un mécanisme de gestion des erreurs basé sur les exceptions qui sont des objets dérivés de la classe Exception.
Lorsqu'un bloc de code peut provoquer des erreurs, on peut les capturer en le plaçant dans la structure:
try {
instruction1;
instruction2;
....
} catch (Exception e) {
instruction_si_erreur;
....
} finally {
....
}
Cela signifie qu'on essaie d'exécuter le bloc d'instructions suivant try et que si une erreur représentée par l'exception e se produit, on exécute le bloc d'instructions suivant catch. Le bloc suivant finally est facultatif, il est exécuté dans tous les cas.
Pour obtenir des renseignements sur l'exception e qui a été déclenchée on peut utiliser ses méthodes getMessage et toString qui renvoient des chaines de caractères.
Ecrivons un programme qui divise deux nombres passés en paramètres en gérant les exceptions. Nous aurons à convertir les chaines fournies en paramètres en nombres, puis à effectuer la division. Deux exceptions peuvent se produire : il n'y a moins de deux paramètres fournis ou les chaines ne peuvent pas être converties.
On peut écrire ce programme de la façon suivante:
public class ajoute {
public static void main(String[] args) {
try {
double d1=Double.valueOf(args[0]).doubleValue();
double d2=Double.valueOf(args[1]).doubleValue();
double r=d1+d2;
System.out.println(d1+"+"+d2+"="+r);
} catch (Exception e) {
System.out.println("Erreur :");
System.out.println(e.toString());
System.out.println("Fin erreur.");
}
}
}
En exécutant le programme avec des paramètres incorrects on obtient des messages indiquant le type d'exception rencontrée.
Par exemple, "java ajoute 3" provoque l'affichage suivant:
Erreur :
java.lang.ArrayIndexOutOfBoundsException: 1
Au revoir...
De même, "java ajoute 5 w" provoque l'affichage de:
Erreur :
java.lang.NumberFormatException: w
Au revoir...
La structure try...catch... peut être complétée en tenant compte du type d'exception rencontrée. Il suffit d'introduire plusieurs clauses catch associée à des types d'exceptions moins généraux que Exception.
On peut ainsi reprendre le programme précédent pour qu'il affiche des messages d'erreur adaptés. Cela nous donne :
public class ajout {
public static void main(String[] args) {
try {
double d1=Double.valueOf(args[0]).doubleValue();
double d2=Double.valueOf(args[1]).doubleValue();
double r=d1+d2;
System.out.println(""+d1+"+"+d2+"="+r);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Entrer deux paramètres !");
} catch (NumberFormatException e) {
System.out.println("Les paramètres doivent être des nombres !");
} catch (Exception e) {
System.out.println("Erreur imprévue.");
} finally {
System.out.println("Au revoir...");
}
}
}
Cette fois, "java ajoute 3" provoque l'affichage suivant:
Entrer deux paramètres !
Au revoir...
Et, "java ajoute 5 w" provoque l'affichage de:
Les paramètres doivent être des nombres !
Au revoir...