Programmparameter

<-- zurck zur Startseite | <- eine Seite vor

  1. Programmparameter einlesen
  2. Kontrolle der Programmparameter
  3. �ung
  4. L�ung

1. Programmparameter einlesen

Programmparameter wurden von uns bereits w�rend dieses Kurses h�fig verwendet, n�lich jedes Mal, wenn wir den Java-Compiler javac oder den Java-Interpreter Javaaufgerufen haben. Als Programmparameter wurde dabei jeweils der Namen der Quelldatei bergeben, durch Leerzeichen getrennt. Auf die selbe Art und Weise k�nen auch Java-Programmen Programmparameter bergeben werden.
Stellen wir uns vor, wir wollten ein Programm schreiben, dass uns Zinsen berechnet. Startkapital, Zinssatz und Laufzeit sollen nicht w�rend der Laufzeit des Programms eingegeben werden, sondern als Programmparameter bergeben werden. Das Programm soll "Zinsberechnung" heissen und k�nte beispielsweise so aufgerufen werden:

java Zinsberechnung 1000 10 3.50

Als ersten Parameter bekommt das Programm das Startkapital (hier: 1000) bergeben, als zweiten die Laufzeit (10 Jahre) und als dritten den Zinssatz (3,5%). Wie wir sehen sind alle Parameter voneinander durch einfache Leerstellen getrennt (und nicht etwa durch Kommata o.�).
Jetzt k�nen wir endlich auch das letzte R�sel um die Methode main lften, n�lich den Grund, warum sie per Definition immer ein String-Array als Argument annimmt. In diesem String-Array werden die Programmparameter abgelegt! Der erste Programmparameter befindet sich dann im Array an der Indexposition 0, der zweite an der Position 1 usw. Unser Programm k�nte nun so aussehen (auf Fehlerbehandlung wurde der Krze wegen verzichtet):

public class Zinsberechnung {

  public static void main(String[] args) {
    double kapital = Double.parseDouble(args[0]);  // Startkapital als erster Programmparameter
    int laufzeit = Integer.parseInt(args[1]);      // Laufzeit als zweiter Programmparameter
    double zinssatz = Double.parseDouble(args[2]); // Zinssatz als dritter Programmparameter
    double multiplikator = 1+(zinssatz/100);
    for (int i=0; i<laufzeit; i++)
        kapital *= multiplikator;
    kapital = Math.round(kapital*100)/100.0;    // Rundung auf zwei Kommastellen
    System.out.println("Nach " + laufzeit + " Jahren betraegt das Kapital " + kapital + " Euro!");
  }

}

Aus dem String-Array "args" werden nacheinander Startkapital, Laufzeit und Zinssatz eingelesen. Da die Programmparameter als Strings aufgenommen werden, sind Typ-Umwandlungen vonn�en (das Kapital wird in eine Kommazahl umgewandelt, da sich sp�er zwangsweise Kommabetr�e bei der Verzinsung ergeben). Der "multiplikator" errechnet sich aus der Dezimaldarstellung des Zinssatzes (deswegen muss die Prozentzahl durch 100 dividiert werden), zu der 1 addiert wird: fr einen Zinssatz von 3,5% ergibt sich damit 1,035. Das Kapital wird dann in jedem Jahr mit diesem Multiplikator multipliziert, danach wird das Ergebnis nach bekannten Methoden auf 2 Nachkommastellen gerundet. Da die Methode round der Klasse "Math" eine Ganzzahl zurckliefert, muss durch 100.0 (Kommazahl!) dividiert werden. Wrde man nur duch 100 dividieren, dann h�ten wir eine reine Integer-Division, deren Ergebnis ebenfalls eine Ganzzahl w�e. Die Nachkommastellen w�en dann jedoch abgeschnitten!

nach oben

2. Kontrolle der Programmparameter

Das Programm funktioniert soweit schon ganz gut, allerdings hat das Programm noch eine unsch�e Seite: werden zu wenige Parameter bergeben, dann werden die Arraygrenzen beim Zugriff berschritten und eine ArrayIndexOutOfBoundsException ausgel�t. Wir verbessern jetzt das Programm dahingehend, dass eine falsche Anzahl von Parametern mit einer eigenen Fehlermeldung quittiert. Eine sehr elegante L�ung dieses Problems besteht darin, eine IllegalArgumentException, also eine Ausnahme bei unglitigen Argumenten auszul�en:

public class Zinsberechnung {

  public static void main(String[] args) {
    if (args.length != 3)
        throw new IllegalArgumentException("Es muessen 3 Parameter uebergeben werden!");
    double kapital = Double.parseDouble(args[0]);  
    int laufzeit = Integer.parseInt(args[1]);      
    double zinssatz = Double.parseDouble(args[2]); 
    double multiplikator = 1+(zinssatz/100);
    for (int i=0; i<laufzeit; i++)
        kapital *= multiplikator;
    kapital = Math.round(kapital*100)/100.0;
    System.out.println("Nach " + laufzeit + " Jahren betraegt das Kapital " + kapital + " Euro!");
  }

}

Hier wird zu Beginn die L�ge des Arrays "args" geprft und damit gleichzeitig die Anzahl der bergebenen Programmparameter. Ist sie gr�ser oder kleiner als 3, so wird eine IllegalArgumentException ausgel�t, mit dem entsprechenden, von uns gesetzten Fehlertext.

Ein andere, oft verwendete M�lichkeit besteht darin, bei falschen Programmparametern eine detaillierte Beschreibung des Programmaufrufs auszudrucken und das Programm manuell zu beenden:

public class Zinsberechnung {

  public static void main(String[] args) {
    if (args.length != 3) {
        System.out.println("Es muessen 3 Parameter uebergeben werden! Aufruf:");
        System.out.println("java Zinsberechnung Startkapital Laufzeit Zinssatz");
        System.exit(1);
    }   
    double kapital = Double.parseDouble(args[0]);  
    int laufzeit = Integer.parseInt(args[1]);      
    double zinssatz = Double.parseDouble(args[2]); 
    double multiplikator = 1+(zinssatz/100);
    for (int i=0; i<laufzeit; i++)
        kapital *= multiplikator;
    kapital = Math.round(kapital*100)/100.0;
    System.out.println("Nach " + laufzeit + " Jahren betraegt das Kapital " + kapital + " Euro!");
  }

}

Werden zu wenige oder zu viele Programmparameter bergeben, bekommt der Anwender mitgeteilt, wie er das Programm korrekt aufzurufen hat. Danach wird ber die Methode exit der Klasse System das Programm abgebrochen, der Rest des Programms wird also nicht mehr ausgefhrt. Die Syntax dieser Methode:

public static void exit(int status)

Dieser Methode wird eine Zahl bergeben: 1 signalisiert einen Programmabbruch aufgrund eines Fehlers, w�rend die Zahl 0 ein fehlerfreies Programmende anzeigt. In unserem Beispiel wird das Programm aufgrund eines Fehlers beendet, daher setzen wir als "Exitcode" die Zahl 1.

Wer schon einmal aus Versehen den Java-Compiler ohne Programmparameter aufgerufen hat, bekommt ebenfalls eine solche Beschreibung (freilich viel ausfhrlicher). Auch viele andere Kommandozeilen-Programme, egal ob Java-Werkzeuge oder beliebige andere Programme, geben derartige Fehlermeldungen aus. Somit haben wir mit dieser Technik ein Werkzeug in der Hand, mit dem wir dem Anwender bekannte Fehlermeldungen bermitteln k�nen.

nach oben

3. �ung

Schreibe ein Programm, dass als Programmparameter den Nettopreis einer Ware und die Stckzahl erh�t. Es soll der Brutto-Gesamtpreis (zuzgl. 16% Mehrwertsteuer) ausgegeben werden. Sorge fr eine gute Fehlerbehandlung!

nach oben

4. L�ung

public class Rechnung {

  public static void main(String[] args) {
    if (args.length != 2) {
        System.out.println("Es muessen 2 Parameter uebergeben werden! Aufruf:");
        System.out.println("java Rechnung Nettopreis Stueckzahl");
        System.exit(1);
    }
    try {  
      double nettopreis = Double.parseDouble(args[0]);  
      int stueckzahl = Integer.parseInt(args[1]);
      double bruttopreis = (nettopreis*stueckzahl)*1.16;      
      double ergebnis = Math.round(bruttopreis*100)/100.0;
      System.out.println("Gesamtbetrag (inkl. MwSt): " + ergebnis);
    } catch (NumberFormatException nfe) {
      System.out.println("Bei den uebergebenen Parametern handelt es sich nicht um gueltige Zahlen!");
      System.out.println("Der Aufruf sollte bspw. so erfolgen:");
      System.out.println("java Rechnung 25.56 10");
    }
  }

}

Zun�hst wird geprft, ob wirklich zwei Parameter bergeben wurden, ansonsten wird hier mit einer Fehlermeldung abgebrochen. Dann wird der erste Parameter (Nettopreis) zu einer Kommazahl, der zweite (Stckzahl) zu einer Ganzzahl umgewandelt. Die Berechnung ist recht einfach, auch das Runden hatten wir schon einmal (siehe Kap. 10). Schl�t das Parsen der eingegebenen Zahlen fehl, wird die Ausnahme abgefangen und dem Anwender mitgeteilt, was er falsch gemacht hat.

nach oben