arguments dans la ligne de commande

Bonjour,

Grand débutant en java, j'ai un petit soucis, je dois exécuter une classe qui passe en arguments 2 nombres et un opérateur et qui affiche le résultat.
Ex: java MaClasse 3 + 2
donne: 3 + 2 = 5

Je ne sais par où commencer...

Merci

C'est quoi ton problème? Tu dois juste l'exécuter ta classe? Ou bien tu dois la coder?

Salut,

Je dois déclencher l'éxécution d'une commande genre:
java MaClasse 3 + 2
Doit me rendre: 3+2=5

MaClasse prend donc 3 arguments, 2 nombres et un opérateur et doit afficher le résultat de l'opération.
Mais je ne comprends pas comment créer cette classe.

Salut,

Voilà un exemple détaillé pour un truc tout simple avec les quatre opérations de base.

Tu vas devoir faire une classe avec un constructeur qui prend trois arguments, tes deux nombres et l'opération souhaitée.

Pour l'opération à mon avis tu peux le gérer avec quatre char + - * /

Code:

1
2
3
4
private static final char OPERATION_ADDITION       = '+';
private static final char OPERATION_SOUSTRACTION   = '-';
private static final char OPERATION_MULTIPLICATION = '*';
private static final char OPERATION_DIVISION       = '/';

Avant d'appeler ton constructeur tu vérifies dans le main que tu as bien trois arguments et qu'ils sont bien du type attendu.

Code:

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
public static void main(final String[] args) {
 
    int nbArg = args.length;
    if (nbArg != 3) {
      System.out.println("Usage  : java Calc nb1 [+-*/] nb2");
      System.out.println("Exemple: java Calc 5 + 3");
 
    } else {
 
      double nombre1 = 0, nombre2 = 0;
      char operation = 0;
 
      try {
        // converti en double le premier argument args[0]
        nombre1 = Double.valueOf(args[0]);
      } catch (NumberFormatException nfe) {
        // TODO Auto-generated catch block
        nfe.printStackTrace();
      }
 
      // check la taille du deuxieme argument
      if (args[1].length() > 1) {
        // TODO message d'erreur
      } else {
        // recupere l'operation sous forme de char
        operation = args[1].charAt(0);
      }
 
      try {
        // converti en double le troisieme argument args[0]
        nombre2 = Double.valueOf(args[2]);
      } catch (NumberFormatException nfe) {
        // TODO Auto-generated catch block
        nfe.printStackTrace();
      }
 
      // si tout s'est bien passé, appel du constructeur
      // tu peux controler aussi la validité des nombres
      if (operation != 0) {
        System.out.println(new Calc(nombre1, nombre2, operation).getResultat());
      }
 
    }
}

Dans ton constructeur tu regardes le type de l'opération, par exemple avec un switch

Code:

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
public Calc(final double nb1, final double nb2, final char op) {
 
  final String operation = nb1 + " " + op + " " + nb2 + " = ";
 
  switch (op) {
  case OPERATION_ADDITION:
    resultat = operation + (nb1 + nb2);
    break;
  case OPERATION_SOUSTRACTION:
    resultat = operation + (nb1 - nb2);
    break;
  case OPERATION_MULTIPLICATION:
    resultat = operation + (nb1 * nb2);
    break;
  case OPERATION_DIVISION:
    if (0 == nb2) {
      resultat = "Erreur : division par 0!";
    } else {
      resultat = operation + (nb1 / nb2);
    }
    break;
  default:
    resultat = "Operation non valide : \"" + op + "\"";
    break;
  }
}

Tu stockes la chaine correspondant à ton opération dans l'attribut "resultat" et tu y concatènes le résultat de l'opération.

Dans l'extrait de code ci-dessus "resultat" est défini comme ceci :

Code:

private String resultat;

Et le getter associé :

Code:

1
2
3
public final String getResultat() {
  return resultat;
}

Ce qui te donne une fois tout mis bout à bout :

Code:

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 Calc {
 
  private static final char OPERATION_ADDITION       = '+';
  private static final char OPERATION_SOUSTRACTION   = '-';
  private static final char OPERATION_MULTIPLICATION = '*';
  private static final char OPERATION_DIVISION       = '/';
 
  private String resultat;
 
  public Calc(final double nb1, final double nb2, final char op) {
 
    final String operation = nb1 + " " + op + " " + nb2 + " = ";
 
    switch (op) {
    case OPERATION_ADDITION:
      resultat = operation + (nb1 + nb2);
      break;
    case OPERATION_SOUSTRACTION:
      resultat = operation + (nb1 - nb2);
      break;
    case OPERATION_MULTIPLICATION:
      resultat = operation + (nb1 * nb2);
      break;
    case OPERATION_DIVISION:
      if (0 == nb2) {
        resultat = "Erreur : division par 0!";
      } else {
        resultat = operation + (nb1 / nb2);
      }
      break;
    default:
      resultat = "Operation non valide : \"" + op + "\"";
      break;
    }
  }
 
  public final String getResultat() {
    return resultat;
  }
 
  public static void main(final String[] args) {
 
    int nbArg = args.length;
    if (nbArg != 3) {
      System.out.println("Usage  : java Calc nb1 [+-*/] nb2");
      System.out.println("Exemple: java Calc 5 + 3");
 
    } else {
 
      double nombre1 = 0, nombre2 = 0;
      char operation = 0;
 
      try {
        // converti en double le premier argument args[0]
        nombre1 = Double.valueOf(args[0]);
      } catch (NumberFormatException nfe) {
        // TODO Auto-generated catch block
        nfe.printStackTrace();
      }
 
      // check la taille du deuxieme argument
      if (args[1].length() > 1) {
        // TODO message d'erreur
      } else {
        // recupere l'operation sous forme de char
        operation = args[1].charAt(0);
      }
 
      try {
        // converti en double le troisieme argument args[0]
        nombre2 = Double.valueOf(args[2]);
      } catch (NumberFormatException nfe) {
        // TODO Auto-generated catch block
        nfe.printStackTrace();
      }
 
      // si tout s'est bien passé, appel du constructeur
      if (operation != 0) {
        System.out.println(new Calc(nombre1, nombre2, operation).getResultat());
      }
 
    }
  }
 
}

Il te reste à effectuer la gestion d'exceptions, pour renvoyer des messages d'erreur du type "le premier argument doit etre un nombre..." et sûrement d'autres détails du style division par zéro auxquels je n'ai pas pensé...

C'est du vite fait pour te montrer le principe, à mon avis il faudrait deplacer le switch dans le main pour eviter de faire un new Calc() si l'opération n'est pas valide.

Si jamais t'as des questions...

A+

Merci c'est très gentil de ta part, ça m'a vraiment aidé à comprendre la construction globale du programme avec les switch, l'appel etc...

Par contre un truc tout bête pour l'exécuter, je dois faire comment ?
Car sous Eclipse, je faits run as Java application et dans la console s'affiche:

Usage : java Calc nb1 [+-*/] nb2
Exemple: java Calc 5 + 3

C'est à dire le message d'erreur si le nombre d'arguments est différent de 3.
Comment rentrer le nombre d'arguments ?

Sinon c'est parfait, encore merci.

Pour l'exécuter dans eclipse, tu cliques sur "Run \ Run configurations..."

A gauche dans la liste "Java Application" tu sélectionnes ta classe

A droite tu sélectionnes l'onglet "Arguments", et dans la zone "Program arguments" tu mets tes arguments, par exemple 3 * 2

Tu cliques sur "Apply", puis "Run"...

Et là, sous tes yeux ébahis, tu vois dans la console "3 * 2 = 6" :D