Schriftzug: Fachbereich Mathematik 
  UHH > Fakultäten > MIN-Fakultät > Mathematik > Java-Kurs   STiNE |  KUS-Portal |  Sitemap Suchen Hilfe there is no english version of this page  
 Index   Buch   DOC   API  Kompaktkurs JAVA   
 <<    <     >    >>  Bock / Löbnitz / Werner

4. Methoden und Verzweigungen

4.1 Methoden (Teil 1)

Das einfachste Java-Analogon zu dem mathematischen Begriff einer reellen Funktion wie f(x)=sin(x) oder f(x)=x3-x+3 ist das einer Methode mit Parameter (entspricht dem Argument x der Funktion) und mit Rückgabewert (entspricht dem Funktionswert f(x)) vom Typ double.

Nehmen wir an, wir wollen eine Wertetabelle für die Funktion f(x)=sin(2x)+cos(x) anlegen. Dann muss f(x) wiederholt ausgewertet werden. Dabei wird die Abbildungsvorschrift nur einmal separat abgespeichert - als Methode:

   static double f(double x){
     return Math.sin(2*x)+Math.cos(x);
   }//Ende des Methodenblocks 

f ist der Bezeichner der Methode, x der Parameter. Das erste double kenzeichnet den Typ des Rückgabewertes. Mit return wird der Rückgabewert der Methode "retourniert". Man achte auf die geschweiften Klammern des Methodenblocks.

Ein Javaprogramm, das eine Wertetabelle mit Hilfe eines Aufrufs dieser Methode erstellt, kann so aussehen:

 class Methode1{
   static double f(double x){
     return Math.sin(2*x)+Math.cos(x);
   }//Ende des Methodenblocks 
   public static void main(String[] args){
     double x=0;
     while (x<1) {
     System.out.println(
          "x="+x+" f(x)="+f(x));
	  x+=0.1;
     }//Ende while
   }//Ende main()
 }//Ende class Methode1

Zunächst wird die Methode f vereinbart. Der Zusatz (Modifier) static muss wie bei der Methode main() stehen, weil es sich um eine Klasse handelt, von der keine Instanz gebildet werden soll, also um eine reine Applikationsklasse. Verstehen kann man dies erst, wenn mit Objekten gearbeitet wird.

Man achte darauf, wie im main()-Block die Methode zur Auswertung der Funktion aufgerufen wird: genauso, wie man es intuitiv machen würde.

In obigem Beispiel war x sowohl ein Bezeichner für den Parameter der Methode f als auch für die Variable im main-Block, die als Parameter in f eingesetzt wird. Das muss nicht sein:

 class Methode1a{
   static double f(double  x){
     return  Math.sin(2*x)+Math.cos(x);
   }//Ende des Methodenblocks 
   public static void main(String[] args){
     double y=0;
     while (y<1) {
       System.out.println(
		   "x="+y+" f(x)="+f(y));
	    y+=0.1;
     }//Ende while
   }//Ende main()
 }//Ende class Methode1a

4.2 Verzweigungen

4.2.1 if, if - else

Verzweigungen erlauben die bedingte Ausführung von Anweisungen und sind damit unerlässlich für die Steuerung von Programmabläufen.

Reelle Funktionen haben zuweilen einen eingeschränkten Definitionsbereich. So muss bei der Wurzelfunktion das Argument nichtnegativ sein, bei rationalen Funktionen darf der Nenner nicht verschwinden. Dies kann im Methodenblock realisiert werden:

   static double f(double x){
     double y; //wird durch y=0 initialisiert
     if ((x>=0) & (x!=4)){ 
       y= 1/(Math.sqrt(x)-2);
     }//Ende des if-Blocks
     return y; //Muss ausserhalb des if-Blocks stehen
   }//Ende des Methodenblocks 

Der if-Block umfasst mehr als eine Anweisung und muss daher durch geschweifte Klammern eingeschlossen werden. Bei nur einer Anweisung können diese Klammern fehlen. Die Syntax einer if-Verzweigung lautet if (A) B. Dabei ist A ein Boole'scher Ausdruck und B ist ein Block von Anweisungen. Wenn A false ist, bewirkt die if-Verzweigung gar nichts.

Der Compiler achtet bei einer Methode mit Rückgabewert streng darauf, dass in jedem Fall ein Wert zurückgegeben wird. Wenn die return y -Zeile in den if-Block wechselt, hat dies eine Fehlermeldung bei der Compilierung zur Folge. Unsere Methode hat den offensichtlichen Nachteil, dass der Wert y=0 zurückgegeben wird, wenn x=4 oder x<0. Mit einem else-Zusatz wird dies anders (s.u.).

Allgemein dienen Verzweigungen dazu, bestimmte Programmteile beim Eintreten gewisser Bedingungen, die erst zur Laufzeit bekannt sind, ausführen zu lassen. In Ergänzung mit else kann die Verzweigung variabler gehandhabt werden:

   //Methode2
   static double f(double x){
     if ((x>=0) & (x!=4)){ 
       double y= 1/(Math.sqrt(x)-2);
       return y;
     }//Ende des if-Blocks
     else {
       System.out.println(
         "x="+x+" ist nicht im Definitionsbereich");
         return Double.NaN;
     }//Ende else-Block
   }//Ende des Methodenblocks 

Die Syntax einer if-else-Anweisung lautet: if (A) B else C. Dabei sind B und C Blöcke von Anweisungen.

Ohne den return-Befehl in vorletzten Zeile hätte es den Compilerfehler Return required at end of double f(double) gegeben. Doch was soll zurückgegeben werden, wenn der Parameter x nicht im Definitionsbereich der Funktion f ist? Zum Glück kennt Java die Konstante Double.NaN, wobei NaN für Not a Number steht und die als double-Rückgabewert akzeptiert wird.

Will man mehrere verschiedene Fälle abarbeiten (Mehrfachverzweigung), sollte man switch verwenden.


4.2.2 switch - case

Unter Umständen reichen aber reine wahr - falsch Bewertungen, wie bei if oder if-else, nicht aus, den Programmfluss zu beeinflussen. Dann ist der Einsatz von switch-case Konstrukten gefragt.

In Abhängigkeit einer integer Variablen können beliebig viele verschiedene Fälle betrachtet werden.

Betrachten wir einmal folgenden Fall: Sie wollen Ihre Ausgabe anpassen und den jeweiligen Wochentag ausgeben:

   //Methode3
   int tag;
   switch (tag) {
      case 1 : System.out.println("Montag");
               break;
      case 2 : System.out.println("Dienstag");
               break;
      case 3 : System.out.println("Mittwoch");
               break;
      case 4 : System.out.println("Donnerstag");
               break;
      case 5 : System.out.println("Freitag");
               break;
      case 6 : System.out.println("Samstag");
               break;
      case 7 : System.out.println("Sonntag");
               break;
   } // Ende switch

Jeder Anweisungsblock sollte (muss nicht!) mit einem break; abgeschlossen werden. Das Wort bedeutet: geh an das Ende der switch Anweisung.

Sollen mehrere Werte betrachtet werden, so können diese zusammengefasst werden:

   //Methode4
   int tag;
   switch (tag) {
      case 1 :
      case 2 :
      case 3 :
      case 4 :
      case 5 : System.out.println("Werktag");
               break;

      case 6 :
      case 7 : System.out.println("Wochenende");
               break;

   } // Ende switch

Auch hier wird die Bearbeitung der switch Anweisung erst beendet, wenn ein break; erreicht wird.

Bitte beachten Sie aber, dass Auswertungen oder Vergleiche wie z.B. switch (tag) { case tag<5: ...} nicht erlaubt sind!

Ein anderer, manchmal sehr nützlicher Bestandteil der switch Anweisung ist die Option default. Stellen Sie sich vor, dass der Wert der Ganzzahl den Wert 7 überschreitet. Jedes ordentliche Programm sollte diesen Fall abfangen und darauf achten, dass nichts Unsinniges passiert. Erweitern wir also das Beispiel Methode3 um diesen Fall:

   //Methode3
   int tag;
   switch (tag) {
      case 1  : System.out.println("Montag");
                break;
      case 2  : System.out.println("Dienstag");
                break;
      case 3  : System.out.println("Mittwoch");
                break;
      case 4  : System.out.println("Donnerstag");
                break;
      case 5  : System.out.println("Freitag");
                break;
      case 6  : System.out.println("Samstag");
                break;
      case 7  : System.out.println("Sonntag");
                break;
      default : System.out.println("Ungültiger Tag");
                break;
   } // Ende switch

Wenn die switch Anweisung keine default-Option enthält, und kein Fall dem aktuellen Wert der Variablen entspricht, werden alle Optionen ignoriert. Die switch Anweisung ist sehr nützlich, aber leider nicht so flexibel, wie in anderen Programmiersprachen.


4.3 Methoden (Teil 2)

Da Methoden ein zentraler Begriff auch des OOP ist, soll der erste Umgang mit ihnen sicherer werden.

Zunächst ein Beispiel für eine Methode mit zwei Parametern und einem Rückgabewert - sämtlichst vom Typ int:

   //Methode5
   static int modulo(int m, int n){
     int M=m;
     while (M>=n) M-=n;
     return M;
   }//Ende modulo
 

Diese Methode modulo berechnet m modulo n (das ist der Rest der Division von m durch n). So, wie die Methode hier programmiert wurde, müssen beide Argumente positiv sein, um eine Endlosschleife zu vermeiden. Java hat hierfür einen eigenen arithmetischen Operator % vorgesehen, so dass es einer Programmierung wie der obigen nicht bedarf.

Es gibt auch Methoden ohne Rückgabewert wie die Methode main(). Diese müssen den Zusatz void tragen. Ein weiters Beispiel einer Methode ohne Rückgabewert ist die Methode System.out.println(). Diese könnte man durch die folgende Methode etwas kürzer mit schreibe() fassen, wenn man Schreibarbeit an der Tastatur sparen will:

   static void  schreibe(String s){
     System.out.println(s);
   }//Ende schreibe()
 


Weiter mit Methoden (Teil 3).


 Index   Buch   DOC   API  Kompaktkurs JAVA   
 <<    <     >    >>  Bock / Löbnitz / Werner

  Seitenanfang  Impressum 2009-03-15, wwwmath (WL)