[Débutante] API DOM : Une erreur de déclaration "parser.parse()" qui ne compile pas

**emykev22** · 16/06/2015, 22h41

Bonjour a vous tous
j'ai besoin de votre aide pour un erreur de declaration API DOM
pourriez vous verifier ma déclaration en rouge car je ne sais pas
ou est l'erreur
merci de votre temps

Voci mon code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
public class calculatrice2 {

public static void main(String[] args) {
    int num1 = Integer.parseInt(args[0]);
	String num2 = (args[1]);
    int num3 = Integer.parseInt(args[2]);
    int numsum = (num1+num3);
    int numsub = (num1-num3);


       DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
       DocumentBuilder parser = factory.newDocumentBuilder();
       Document doc = parser.parse();
		Element math = doc.createElement("math");
		math.setAttribute("xmlns","http://www.w3.org/1998/Math/MathML");
       		doc.appendChild(math);       		Element mrow = doc.createElement("mrow");
       		Element mn1 = doc.createElement("mn");
     		mn1.appendChild(doc.createTextNode(args[0]));
		Element mo1 = doc.createElement("mo");
     		mo1.appendChild(doc.createTextNode(args[1]));
       		Element mn2 = doc.createElement("mn");
       		mn2.appendChild(doc.createTextNode(args[2]));
       		Element mo2 = doc.createElement("mo");
       		mo2.appendChild(doc.createTextNode("="));
       		Element mn3 = doc.createElement("mn");
       		mn2.appendChild(doc.createTextNode("results"));
		Element mrow1 = doc.createElement("mrow");
       		Element mtext = doc.createElement("mtext");
		mtext.appendChild(doc.createTextNode("vrai"));
			mrow.appendChild(mn1);
			mrow.appendChild(mo1);
			mrow.appendChild(mn2);
			mrow.appendChild(mo2);
			mrow.appendChild(mn3);
			mrow.appendChild(mrow1);
			mrow1.appendChild(mtext);
			math.appendChild(mrow);
switch (args[2])
{
//Addition
case "+":
Element mn6 = doc.createElement (  "mn");
mn6.appendChild(doc.createTextNode(Integer.toString(numsum)));
//Soustraction
case "-":
Element mn7 = doc.createElement (  "mn");
mn7.appendChild(doc.createTextNode(Integer.toString(numsub)));

//Comparaisons
case "&lt":
	if(Integer.parseInt(args[1])<Integer.parseInt(args[3]))
		//Result=="vrai";
		{Element mtext1 = doc.createElement ("mtext");
		mtext.appendChild(doc.createTextNode("vrai"));}
	else //Result=="faux";
		{Element mtext2 = doc.createElement ("mtext");
		mtext.appendChild(doc.createTextNode("faux"));}
case "&gt":
	if(Integer.parseInt(args[1])>Integer.parseInt(args[3]))
		//Result=="vrai";
		{Element mtext3 = doc.createElement ("mtext");
		mtext.appendChild(doc.createTextNode("vrai"));}
	else //Result=="faux";
		{Element mtext4 = doc.createElement ("mtext");
		mtext.appendChild(doc.createTextNode("faux"));}
}

   TransformerFactory tfact = TransformerFactory.newInstance();
       Transformer transformer =  tfact.newTransformer();
          transformer.setOutputProperty("encoding", "ISO-8859-1");
   DOMSource source = new DOMSource(doc);
   FileWriter fw = new FileWriter(args[0]);

StreamResult result = new StreamResult(System.out);
transformer.transform(source, result);}
}

voici input attendu lorsque je tape la ligne de commande suivante
java calculatrice2 2-1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
<?xml version="1.0" encoding="ISO-8859-1"?>
 <math xmlns="http://www.w3.org/1998/Math/MathML">
   <mrow>
     <mn>2</mn>
     <mo>-</mo>
     <mn>1</mn>
     <mo>=</mo>
     <mn>1.0</mn>
   </mrow>
 </math>

et voici le resultat attendu lorsque je tape la ligne de commande
java calculatrice2 1.5 "<" 2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
<?xml version="1.0" encoding="ISO-8859-1"?>
 <math xmlns="http://www.w3.org/1998/Math/MathML">
   <mrow>
     <mn>1.5</mn>
     <mo>&lt;</mo>
     <mn>2</mn>
     <mo>=</mo>
     <mrow><mtext>vrai</mtext></mrow>
  </mrow>
  </math>

je pense que je suis encore loin de la solution!

**joel.drigo** · 16/06/2015, 23h24

Salut,

DocumentBuilder.parse() est fait pour "lire" une source (un fichier par exemple).
Pour créer un Document, il faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
DocumentBuilder documentBuilder = factory.newDocumentBuilder();
Document doc = documentBuilder.newDocument();

Ensuite, il y a plusieurs méthodes que tu appelles qui soulèvent des exceptions, qu'il te faudra attraper (try/catch ou throws).
Il y a par ailleurs un problème dans le résultat, mais je te laisse regarder ça toi-même pour l'instant (indice : il faut tester l'opérateur)

**emykev22** · 17/06/2015, 17h55

Envoyé par joel.drigo

Salut,

DocumentBuilder.parse() est fait pour "lire" une source (un fichier par exemple).
Pour créer un Document, il faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
DocumentBuilder documentBuilder = factory.newDocumentBuilder();
Document doc = documentBuilder.newDocument();

Ensuite, il y a plusieurs méthodes que tu appelles qui soulèvent des exceptions, qu'il te faudra attraper (try/catch ou throws).
Il y a par ailleurs un problème dans le résultat, mais je te laisse regarder ça toi-même pour l'instant (indice : il faut tester l'opérateur)

Un gros merci pour l'aide!

mon code fonctionne lorsque je tape la ligne de commande
java calculatrice 2 - 1
mais lorsque j'utilise
java calculatrice 1.5 "<" 2
la rien ne va plus
et je ne sait pas comment utilise try et catch dans les paramétrés entre
pourriez vous m'aide S.V.P

voici mon nouveau code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
public class calculatrice2 {
 
public static void main(String[] args) throws Exception {
    double num1 = Integer.parseInt(args[0]);
	String num2 = (args[1]);
    double num3 = Integer.parseInt(args[2]);
    double numsum = (num1+num3);
    double numsub = (num1-num3);
 
 
       DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
       DocumentBuilder documentBuilder = factory.newDocumentBuilder();
       Document doc = documentBuilder.newDocument();
		Element mrow = doc.createElement("math");
		mrow.setAttribute("xmlns","http://www.w3.org/1998/Math/MathML");
       		doc.appendChild(mrow);
 
            Element mrow0 = doc.createElement("mrow");
			mrow.appendChild(mrow0);
       		Element mn1 = doc.createElement("mn");
			mrow.appendChild(mn1);
 
     		mn1.appendChild(doc.createTextNode(args[0]));
		    Element mo1 = doc.createElement("mo");
			mrow.appendChild(mo1);
 
     		mo1.appendChild(doc.createTextNode(args[1]));
       		Element mn2 = doc.createElement("mn");
			mrow.appendChild(mn2);
 
       		mn2.appendChild(doc.createTextNode(args[2]));
       		Element mo2 = doc.createElement("mo");
			mrow.appendChild(mo2);
 
       		mo2.appendChild(doc.createTextNode("="));
			mrow.appendChild(mo2);
 
switch (num2)
{
case "+":
     Element mn3 = doc.createElement("mn");
              String numsum1 = Double.toString(numsum);
     mn3.appendChild(doc.createTextNode(numsum1));
	 mrow.appendChild(mn3);
 
	 Element mrow2 = doc.createElement("mrow");
     mrow.appendChild(mrow2);
 
 break;
case "-":
	Element mn7 = doc.createElement (  "mn");
     Element mn4 = doc.createElement("mn");
         String numsub1 = Double.toString(numsub);
     mn4.appendChild(doc.createTextNode(numsub1));
	 mrow.appendChild(mn4);
 
	 Element mrow3 = doc.createElement("mrow");
	 mrow.appendChild(mrow3);
 break;
case "&lt":
if(Integer.parseInt(args[1])<Integer.parseInt(args[3]))
		{	Element mtext = doc.createElement("mtext");
		    mtext.appendChild(doc.createTextNode("vrai"));
			mrow.appendChild(mtext);
			mrow.appendChild(mrow);
	    }
case "&gt":
if(Integer.parseInt(args[1])>Integer.parseInt(args[3]))
		{	Element mtext = doc.createElement("mtext");
		    mtext.appendChild(doc.createTextNode("vrai"));
			mrow.appendChild(mtext);
			mrow.appendChild(mrow);
		}
 break;
}
// Affichage du document en ligne de commande
   TransformerFactory tfact = TransformerFactory.newInstance();
   Transformer transformer =  tfact.newTransformer();
   transformer.setOutputProperty("encoding", "ISO-8859-1");
   DOMSource source = new DOMSource(doc);
   FileWriter fw = new FileWriter(args[0]);
   StreamResult result = new StreamResult(System.out);
   transformer.transform(source, result);
 
}}

**joel.drigo** · 17/06/2015, 20h10

Envoyé par emykev22

...
mais lorsque j'utilise
java calculatrice 1.5 "<" 2
la rien ne va plus

C'est normal :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

case "&lt":

On est pas en html/xml. Pas besoin d'échapper le < dans une String Java. Fais directement [c]case "<":[/code].

Envoyé par emykev22

...

et je ne sait pas comment utilise try et catch dans les paramétrés entre

Mais dans le cas général, si tu as un statement qui soulève une exception (autre qu'une RuntimeException), il faut la traiter explicitement.

Par exemple, dans ton code, factory.newDocumentBuilder(); produit une exception ParserConfigurationException. On peut la traiter de différentes manières. Laquelle est là mieux ? Ça dépend, de ce que tu veux faire, et de ce que l'application doit faire, et du service que tu vas donner à l'utilisateur (message d'information, log pour le développeur, autocorrection, etc..., faire que ça plante pas lamentablement...) : et pour ça on a 2 outils.

Le catch, permet d'attraper l'erreur est de faire le traitement à cet endroit.

Par exemple, lorsqu'on appelle parseInt() sur une chaine qui ne peut pas être transformée en int, on obtient une NumberFormatException.

On peut donc écrire quelque chose comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static void main(String[] args) throws Exception {
	String operateur = (args[1]);
	try {
	    double num1 = Integer.parseInt(args[0]);
		try {
			double num3 = Integer.parseInt(args[2]);
			run(num1, operateur, num3);
		}
		catch( NumberFormatException e) {
			System.err.println("Erreur: le second opérande doit être un nombre !");
		}
	}
	catch( NumberFormatException e) {
		System.err.println("Erreur: le premier opérande doit être un nombre !");
	}
}
 
private static void run(double num1, String num2, double num3)  throws Exception {
 
    double numsum = (num1+num3);
    double numsub = (num1-num3);
 
/*...*/

L'autre moyen est le throws : on l'utilise quand on ne sait pas quoi faire de l'exception, ou que ce n'est pas logique qu'on s'en occupe à notre niveau de code. C'est pour ça d'ailleurs que parseInt() retourne une NumberFormatException au lieu d'affiche un message : ce n'est pas à cette méthode de décider d'afficher quelque chose. Chaque programme, voire chaque méthode pourra réagir de façon différente et non prévisible à cette erreur.

Bien sûr, il y a des erreurs techniques qu'on ne peut pas vraiment résoudre et autant faire un throws : par exemple, en cas IOException une lecture de fichier en plein milieur, plutôt que de mettre un laconique ("impossible de lire la fin de "truc.machin" : votre fichier est peut-être corrompu, ou votre disque a peut-être des secteurs défectués, ou je ne sais quoi...", autant laisser la stack trace de base s'afficher.

Maintenant, il vaut mieux éviter de faire un throws Exception. Il vaut mieux faire des throws de chaque exceptions qui sont remontées. Ceci essentiellement afin de traiter vraiment les exceptions qui sont censé être traitées dans le code qui appelle la méthode (avec throws Exception, l'appelant sera obliger de faire catch Exception, ce qui ne l'aidera pas s'il veut faire un traitement différencié des différentes exceptions). Pour la méthode main() c'est différent, c'est rare qu'on l'appelle, mais ce n'est pas impossible : autant ne remonter que les exceptions qui sont vraiment soulevables dans le code. Il y a aussi une histoire de performance, mais là aussi, dans le cas de ton programme, c'est négligeable.

Ensuite, il y a des cas où on peut s'arranger pour que l'exception ne se produise pas. Par exemple, on sait que l'utilsateur peut oublier des paramètres, ou peut taper un opérateur qu'on ne traite pas(la multiplication par exemple, ou même un caractère qui n'a pas de sens en tant qu'opérateur). Plutôt que d'espérer que ça plantera à cause d'une exception, ou, pire, que ça donne un résultat incompréhensible, autant tester ces cas, lorsqu'on le peut.

Par exemple, dès le début :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
if ( args.length()< .. ) {
 
System.err.println("Il manque des paramètres"); // par exemple
 
}
else {
/*...*/

Par ailleurs, je n'ai pas lu tout ton code, mais j'ai vu 2 ou 3 choses qui ne vont pas :

double num1 = Integer.parseInt(args[0]);Ce n'est pas très logique : si on parse une String de cette maniètre, on obtient un entier (un int). Pourquoi le mettre dans un double ? N'est-ce pas plutôt un double que tu veux parser ?
[c]double num1 = Double.parseDouble(args[0]);
Ensuite évite de faire plusieurs fois la même chose (des Integer.parseInt(args[3)); par exemple). D'ailleurs débarrasse toi au plus tôt des paramètres de type tableau. Ceci te permet d'avoir des paramètres bien identifiés aux types identifiés (on a un opérande de type double, un opérateur de type String, un autre opérante de type double et un nom de fichier). Plutôt qu'un tableau de String[] que tu parses sans arrêt. Au moins, ça t'évitera les erreurs comme celle de faire :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
FileWriter fw = new FileWriter(args[0]);
```
à la fin de ton code,

Alors qu'au début :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
 double num1 = Integer.parseInt(args[0]);
```
Il y a quelque chose de pas logique. Remarque ce n'est pas impossible que le fichier ait pour nom la valeur de l'opérande, mais à mon avis, ce n'est pas ce que tu voulais/devais faire.

D'autre part, ça t'évitera en cas de modification du code, de devoir faire la modification à plusieurs endroits, et donc d'en favoriser l'oubli.
Une autre chose : des noms adaptés et significatifs sont préférables, pour ne pas se tromper, ou lire plus facilement le code pour le déboguer :
Tu as écrit String num2 = args[1]; alors que String operateur = args[1] sera plus clair : on sait que c'est l'operateur en voyant le nom de la variable.
il y en a peut-être d'autres, mais je vais arrêter là pour le moment.

**emykev22** · 18/06/2015, 21h49

Encore merci pour toutes les explications données

J'ai modifié mom code avec le try sa fonctionne bien lorsque Je tape la ligne de commande !

java calculatrice 2 - 1
malgre que le output est en chiffre double plutôt d'avoir 2 a l'écran j'ai 2.0

mais lorsque je tape

java calculatrice 1.5 "<" 2
je tomber dans l'erreur du cath "le premier operade doit être un nombre"
il ne prend pas le double
comment faire pour avoir des parametres différents en entré
est-ce que je doit formatter mon entre et comment

Merci encore de tout ton temps je ne sais comment te remercier...

**joel.drigo** · 19/06/2015, 02h45

Mais as-tu bien remplacé les Integer.parseInt() par des Double.parseDouble() ?

Sur le fait que ça affiche 2.0 quand tu saisi 2, c'est parce que justement tu stocke la valeur dans un double. Si tu as besoin d'obtenir une valeur sans le .0 à la fin, il faudra l'enlever par du code.

On peut faire par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public static String toString(double valeur) {
 
    String string = String.valueOf( valeur ) ;
 
    if ( string.endsWith(".0") ) {
        return string.substring(0, string.length()-2);
    }
    else {
       return string;
    }
 
}

Et utiliser cette méthode au lieu d'un String.valueOF() pour faire la conversion.

Si on veut pouvoir sortir une valeur qui correspond aux paramètres en entrée, c'est-à-dire un entier lorsque les 2 paramètres sont entiers, on peut stocker un booléen dès le début :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

boolean tousentiers = arg[0].indexOf('.')==-1 && arg[2].indexOf('.')==-1; // adapter les idnex en fonction de la position de tes paramètres

Et pour la conversion (le paramètre "entier" à passer est la variable tousentiers) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
public static Strnig toString(double valeur, boolean entier) {
      if( entier ) {
         return String.valueOf((int)valeur);
      }
      else {
         return String.valueOf(valeur);
      }
}

[Débutante] API DOM : Une erreur de déclaration "parser.parse()" qui ne compile pas

Format d'échange (XML, JSON...) Java

Vue hybride

Discussions similaires

Partager

Partager