Discussion :

[emykev22]

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]

Salut,

1. 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();

2. Ensuite, il y a plusieurs méthodes que tu appelles qui soulèvent des exceptions, qu'il te faudra attraper (try/catch ou throws).
3. 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]

Salut,

1. 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();

2. Ensuite, il y a plusieurs méthodes que tu appelles qui soulèvent des exceptions, qu'il te faudra attraper (try/catch ou throws).
3. 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]

...
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].

...

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 :

1. 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]);
2. 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.
   
3. 
   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.
4. il y en a peut-être d'autres, mais je vais arrêter là pour le moment.

[emykev22]

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]

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);
      }
}

[emykev22]

Selon ce que j'ai compris comme débutante
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
public static void main(String[] args) throws Exception {

	boolean operateur = arg[1].indexOf('"')==+1 && arg[3].indexOf('"')==-1;
	try {
	    double num1 = Double.parseDouble(args[0]);
		try {
			double num3 = Double.parseDouble(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, boolen operateur, double num3)  throws Exception {

    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);


            String num1s = String.valueOf(num1) ;
            if ( num1s.endsWith(".0") ) {
               num1s = num1s.substring(0, num1s.length()-2);

            }
     		mn1.appendChild(doc.createTextNode(num1s));
    	    mrow.appendChild(mn1);

		    Element mo1 = doc.createElement("mo");
			mrow.appendChild(mo1);


     		mo1.appendChild(doc.createTextNode(operateur));
       		Element mn2 = doc.createElement("mn");
			mrow.appendChild(mn2);

            String num3s = String.valueOf(num3) ;
            if ( num3s.endsWith(".0") ) {
               num3s = num3s.substring(0, num3s.length()-2);

            }
       		mn2.appendChild(doc.createTextNode(num3s));
			mrow.appendChild(mn2);

       		Element mo2 = doc.createElement("mo");
			mrow.appendChild(mo2);

       		mo2.appendChild(doc.createTextNode("="));
			mrow.appendChild(mo2);

switch (operateur)
{
case "+":
       String numsum1 = Double.toString(numsum);
       Element mn3 = doc.createElement("mn");
       mn3.appendChild(doc.createTextNode(numsum1));
	   mrow.appendChild(mn3);
       break;
case "-":
       String numsub1 = Double.toString(numsub);
       Element mn4 = doc.createElement("mn");
       mn4.appendChild(doc.createTextNode(numsub1));
	   mrow.appendChild(mn4);
         break;
case "<":

	   Element mrow3 = doc.createElement("mrow");
       mrow.appendChild(mrow3);

       Element mtext = doc.createElement("mtext");
	   mtext.appendChild(doc.createTextNode("vrai"));
	   mrow.appendChild(mtext);

	   Element mrow4 = doc.createElement("mrow");
	   mrow.appendChild(mrow4);
       break;

case">":
	   Element mrow5 = doc.createElement("mrow");
	   mrow.appendChild(mrow5);

       Element mtext1 = doc.createElement("mtext");
	   mtext1.appendChild(doc.createTextNode("Faux"));
	   mrow.appendChild(mtext1);
	   Element mrow6 = doc.createElement("mrow");
	   mrow.appendChild(mrow6);
       break;
}
   Element mrow2 = doc.createElement("mrow");
   mrow.appendChild(mrow2);

Maintenant lorsque je tape la ligne de commande
java calculatrice 2 - 1
Le résultat est bon et les chiffre sont des entiers selon vos conseils

Lorsque je tape la ligne de commande
java calculatrice 1.5 "<" 2

Le résultat est bon a l’exception des lignes que j'ai mis rouge qui ne s'affiche pas à l’écran
Pourriez vous vérifiez S.V.P.
P.S. je sais que le code pourrait être amélioré...

[joel.drigo]

Pour la première ligne "rouge" :

Code :

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

	boolean operateur = arg[1].indexOf('"')==+1 && arg[3].indexOf('"')==-1;

J'avais écrit : boolean tousentiers = arg[0].indexOf('.')==-1 && arg[2].indexOf('.')==-1;. Donc rien à voir avec ce que tu as écrit.

Le but de cette ligne est juste de déterminer si tous les opérandes (les valeurs qui sont utilsisées dans les calculs) si sont tous entier, parce que le résultat est entier que si tous les opérandes sont entiers (1 + 1 = 0, mais 1.5 + 1 = 1.5). Parce que tu voulais un résultat dans ton xml du type "1" comme on rentre des entiers, et pas "1.0".

Pour tester si un nombre est un entier ou un double, on teste s'il y a un . (un point) dedans. Dans ton code tu cherches si le nombre contient une double-quote... Ensuite, indexOf() détermine la position du caractère passé en paramètre : si cette position est égale à -1, le caractère ne se trouve pas dans la chaîne. -1, pas +1.

Ensuite, ce booléen n'a rien à voir avec l'opérateur : l'opérateur c'est un caractère pas un booléen déjà. Et l'opérateur c'est, comme tu l'avais fait dès le début le paramètre entre les 2 opérandes. Simplement dans ton code, à la fin tu utilises le paramètre arg[0] comme nom de fichier, alors qu'au début du programme tu l'utilise comme opérande numéro 1 : ça ne peut pas être les 2 à la fois (enfin si ça pourrait, mais je suppose que ce n'est pas ce que tu veux faire, sinon, si tu fais le calcul 1 + 1, ton fichier va s'appeler 1. Donc déjà il faut que tu décides d'où vient le nom du fichier.


Mais si on part sur la base que les paramètres sont opérande 1, opérateur, opérande 2, alors le code au début doit être tout simplement :

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
 
public static void main(String[] args) throws Exception {
 
         boolean tousentiers = arg[0].indexOf('.')==-1 && arg[2].indexOf('.')==-1; // on détermine si les 2 opérandes sont entiers (si ils le sont tous les 2, alors le résultat sera un entier, sinon ce sera un nombre à virgule (enfin à point exactement)
         try {
	    double num1 = Double.parseDouble(args[0]); // on lit l'opérande 1 dans le paramètre 0
		try {
			double num2 = Double.parseDouble(args[2]); // on lit l'opérande 2 dans le paramètre 2
                        String operateur = args[1]; // on lit l'opérateur dans le paramètre 1
			run(num1, operateur, num2, tousEntier); // on appelle la méthode qui génère le xml avec les paramètres qu'on a besoin
		}
		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, boolen operateur, double num2, boolean tousEntier)  throws Exception {
 
double resultat;
switch( operateur ) { // on teste l'opérateur
case "+": // si l'opérateur est une addition
    resultat = num1 + num2; // on calcule le résultat (donc la somme des 2 nombres)
    // etc...
    break;
}

Et pour déterminer la chaîne résultat à mettre dans le résultat, il faut utiliser tousEntier pour savoir si le résultat doit être pris comme un entier ou un double au moment de la conversion en String (comme j'ai miontré dans un de mes précédents messages). Ceci, si tu veux que le résultat soit cohérent avec les opérandes. Maintenant, si tu veux simplement que si le résultat se termine par .0 alors on l'exporte en entier, alors il faut faire comme tu as fait là :

Code :

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

1
2
3
4
String num1s = String.valueOf(num1) ;
if ( num1s.endsWith(".0") ) {
    num1s = num1s.substring(0, num1s.length()-2);
}

Très bien.

Mais :

1. Fais une méthode : ne répète pas ce code pour num1, num2 et le résultat (ça fait trois répétions de la même chose)
2. Dans ce cas le booléen tousEntier ne sert plus à rien : supprime-le.

Donc je reprends ;

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
public static void main(String[] args) throws Exception {
 
         try {
	    double num1 = Double.parseDouble(args[0]); // on lit l'opérande 1 dans le paramètre 0
		try {
			double num2 = Double.parseDouble(args[2]); // on lit l'opérande 2 dans le paramètre 2
                        String operateur = args[1]; // on lit l'opérateur dans le paramètre 1
			run(num1, operateur, num2); // on appelle la méthode qui génère le xml avec les paramètres qu'on a besoin
		}
		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, boolen operateur, double num2, boolean tousEntier)  throws Exception {
 
       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);
 
       // operande 1
       Element mn1 = doc.createElement("mn");
       mrow.appendChild(mn1);
       mn1.appendChild(doc.createTextNode( toString( num1 ) );
 
       // operateur
       Element mo1 = doc.createElement("mo");
       mrow.appendChild(mo1);
       mo1.appendChild(doc.createTextNode(operateur));
 
       // operande 2
       Element mn2 = doc.createElement("mn");
       mrow.appendChild(mn2);
       mn2.appendChild(doc.createTextNode( toString( num2 ) );
 
       // =
       Element mo2 = doc.createElement("mo");
       mrow.appendChild(mo2);
       mo2.appendChild(doc.createTextNode("="));
 
 
       // resultat 
       Element mnr = doc.createElement("mn");
       mrow.appendChild(mnr);
 
switch( operateur ) { // on teste l'opérateur
case "+": // si l'opérateur est une addition
    // on calcule le résultat (donc la somme des 2 nombres)
    mnr.appendChild(doc.createTextNode( toString( num1 + num2 ) ) );
    break;
case "-":
    num1 - num2; // on calcule le résultat (donc la différence)
    mnr.appendChild(doc.createTextNode( toString( num1 + num2 ) ) );
    break;
case ">";
    // on calcule le résultat (donc si num1 > num2 )
    mnr.appendChild(doc.createTextNode( toString( num1 > num2 ) ) );
    break;
case "<";
    // on calcule le résultat (donc si num1 < num2 )
    mnr.appendChild(doc.createTextNode( toString( num1 < num2 ) ) );
    break;
 
/* ... etc ... */
 
}
 
// écriture du fichier
/* ... */
 
 
}
 
// on convertit un double en chaine (si le double n'a pas de décimales, alors il sort sous forme d'entier)
private static String toString(double value) {
   String string = String.valueOf(value);
   if ( string.endsWith(".0") ) {
      string = string.substring(0, string.length()-2);
   }  
   return string;
}
 
// on convertit un boolean en chaine, tel que true sorte en "vrai" et false en "faux"
private static String toString(boolean value) {
    if ( value ) {
       return "vrai";
    }
    else {
       return "faux";
    }
}

[emykev22]

Un gros merci pour tout
J’ai fait quelque ajustement pour le output mais tout fonctionne très bien
Encore merci pour tout
Java avec Api Dom n'ai pas si facile a programmer que ça, il y a beaucoup de détail à apprendre
ENCORE MERCI
Ton aide, ma été précieuse

A la prochaine...