Methoden

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

  1. Methodendeklaration
  2. Rckgabewerte
  3. mehrere üergabeparameter

1. Methodendeklaration

Eine der Grundregeln beim Programmieren lautet, dass man nie den selben Code zweimal schreiben soll. Um derartige Probleme anzugehen, kann man Programmteile in eigene Methoden auslagern. Zum einen tut dies der Üersichtlichkeit gut, zum anderen hab ich kein großes Problem mehr, wenn ich daran etwas ändern will: ich brauche dann nur noch den Code in der Methode ändern, und die Änderung wird automatisch an allen Stellen wirksam, an denen die Methode aufgerufen wird.
Eine Unterscheidung zwischen Funktionen und Prozeduren, wie Pascal, kennt Java hingegen nicht. Genau genommen handelt es sich in Java genau genommen um (statische) Klassenmethoden, da wir uns in Java ja außchließlich innerhalb von Klassen bewegen. Darauf gehen wir näher bei der objektorientierten Programmierung ein. Methoden nehmen den Platz ein, den Funktionen in anderen Programmiersprachen haben. Die fehlende Unterscheidung zwischen Funktionen und Prozeduren führt auch dazu, dass in eine Methode keine andere Methode eingebettet werden kann, sondern für sich alleine stehen müssen. Methoden sind - einfach gesprochen - Funktionen innerhalb von Klassen.
Eine Methode kennen wir schon, nämlich die Startmethode main. An ihr können wir jetzt auch gleich den Aufbau einer Methode aufdröseln:

public static void main(String[] args)

Der allgemeine Aufbau einer Methodendeklaration ist:

public static Rückgabewert Name([übergebene Parameterliste])

Vorerst werden wir Methoden immer mit public static einleiten. Für's erste langt es uns, wenn wir uns damit abfinden, dass dies im Grunde nur eine spezielle Form von Methoden ist. Es erfüllt seinen Zweck, außerdem werden wir darauf im Einzelnen bei der objektorientierten Programmierung eingehen. Auf "public static" folgt der Rückgabewert: hier können sowohl primitive Datentypen stehen als auch der Name eines Objekts bzw. seiner Klasse. Bei unserer "main"-Methode ist der Rückgabewert, wie wir sehen void (leer). Das bedeutet, dass diese Methode nur ausführt, aber keinen Rückgabewert hat. (C++-Freunde sollte sich nicht irritieren lassen davon, dass in C/C++ die main-Funktion einen Integerwert zurckgibt)
Hierauf folgt der Name der Methode. Der Name der Methode "main" ist vorgeschrieben, aber alle anderen Methoden, die wir selbst schreiben, können wir benennen, wie wir wollen. In den runden Klammern knnen der Funktion schließlich Parameter (Variablen) übergeben werden, die sie verarbeiten soll.
Beispielsweise wollen wir eine Methode "halbiere" schreiben, die eine "double"-Zahl halbiert. Dazu müssen wir der Funktion eine "double"-Variable übergeben, diese teilt dann durch 2 und gibt das Ergebnis (ebenfalls wieder "double") zurück.
Also fassen wir zusammen:
- Rckgabewert: "double"
- Name: "halbiere"
- übergebene Parameter: ein "double"-Wert

Die Methodendeklaration sieht nun so aus:

public static double halbiere(double unsereZahl)

Wie wir sehen, muss zu jeder übergebenen Variable (Parameter) auch der Datentyp (hier "double") angegeben werden. Der übergebenen Variablen können wir wieder einen beliebigen Namen geben, der sogar mit dem Namen der Varibalen im "Hauptprogramm" übereinstimmen darf! Denn für diese Methode wird dann eine Kopie der Variable angelegt, die nur innerhalb der Funktion gilt! Ergo ist die Variable nur innerhalb der Methode sichtbar, kann von außen nicht angesprochen werden und wird beim Verlassen der Methode wieder vernichtet. Dies gilt auch für Variablen, die in einer Methode definiert werden und nicht übergeben werden. Ihr Geltungsbereich ist genauso beschränkt.

nach oben

2. Rckgabewerte

Damit der berechnete Wert aus der Methode zurückgegeben werden kann, gibt es das Schlüsselwort return. Sehen wir uns ein erstes Beispiel an:

public class Methoden1 {

   public static double halbiere(double unsereZahl) {
       double rueckgabewert = unsereZahl / 2.0;
       return rueckgabewert;
   }

  public static void main(String[] args) {
      double test = 4.646;
      double ausgabe = halbiere(test);
      System.out.println("Wert: " + ausgabe);
   }

}

In der main-Methode wird zunächst eine Variable vom Typ "double" angelegt. Die Methode "halbiere" wird aufgerufen, indem man zwischen den runden Klammern alle erforderlichen Parameter übergibt. Nimmt die Methode keine Parameter, bleibt die Klammer natürlich leer. Jetzt springt das Programm in die Methode "halbiere". Da Variablen sowie übergebene Parameter nur in der Methode gültig sind, in der sie angelegt werden, kann man auf die Variablen "rueckgabewert" und "unsereZahl" nicht von außen - sprich der Methode "main" - zugreifen (lesen und/oder verändern). Die Methode wird nun abgearbeitet, bis sie durch "return" verlassen wird. Dem Schlüsselwort "return" wird schließlich der Wert übergeben, den die Methode zurückliefern soll. Anweisungen, die nach "return" stehen, werden nicht mehr abgearbeitet, weswegen "return" üblicherweise am Ende einer Methode steht.
In der main-Methode muss der Rückgabewert - hier "double" - selbstverständlich aufgefangen werden: man kann ihn z.B. mit dem Zuweisungsoperator "=" einer Variable zuweisen.

Wichtig ist, dass der Methode nicht nur eine Variable vom Typ "double" übergeben werden kann, sondern auch ein Kommazahl als Literal (evtl. notwendige Typumwandlungen werden - wie in Kap. 8 erklärt - mit den nachgestellten Buchstaben "f", "d" und "l" oder mit "Type-Casts" durchgeführt):

double ausgabe = halbiere(4.646);

Die Methode "halbiere" kann man noch krüzer schreiben! Wir brauchen z.B. in diesem Fall in der Methode "halbiere" nicht noch eine "double"-Variable deklarieren, sondern geben das Ergebnis der Rechnung direkt zurück, da der mathematische Ausdruck einen "double"-Wert liefert:

public static double halbiere(double unsereZahl) {
    return unsereZahl/2.0;
}

Außerdem brauchen wir auch nicht unbedingt eine neue Variable, um das Ergebnis der Methode abzufangen. Wir können der Methode die Variable "test" übergeben und das Ergebnis wieder in "test" speichern:

public class Methoden1 {

   public static double halbiere(double unsereZahl) {
       return unsereZahl / 2.0;
   }

  public static void main(String[] args) {
      double test = 4.646;
      test = halbiere(test);
      System.out.println("Wert: " + test);
   }

}

nach oben

3. mehrere üergabeparameter

Natürlich kann eine Methoden auch mehr als einen Parameter erhalten. Man spricht dann auch von einer sog. Parameterliste. Erstellen wir eine Methode, die einen (ganzzahligen) Mittelwert von zwei Ganzzahlen zurückgeben soll (da sowohl Zöhler als auch Nenner ganzzahlig sind, ist das Ergebnis der Division automatisch "integer", wir können uns also den "Cast" sparen):

public static int mittelwert(int zahl1, int zahl2) {
    return (zahl1+zahl2)/2;
}

Und natürlich können wir auch Methoden schreiben, die gar keine Parameter erhalten. Beispielsweise lagern wir eine Methode aus, in der wir mehrmals "Hallo" wiederholen wollen.

public static void sagHallo() {
    System.out.println("hallo hallo hallo");
}

Da wir hier auch keinen Rückgabewert haben, ist die Funktion void! Natürlich brauchen wir dann auch nicht das Schlüsselwort return, um einen Wert zurückzuliefern. Die Methode wird automatisch verlassen, wenn ihr Ende - die schließende geschweifte Klammer - erreicht wird.
Ein kleines Beispiel mit allen bisher erstellten Methoden (über Nutzwert und Sinnhaftigkeit unterhalten wir uns jetzt noch nicht):

public class Funktionen2 {

   public static double halbiere(double unsereZahl) {
       return unsereZahl / 2.0;
   }

   public static int mittelwert(int zahl1, int zahl2) {
       return (zahl1+zahl2)/2;
   }

   public static void sagHallo() {
       System.out.println("hallo hallo hallo");
   }

  public static void main(String[] args) {
      double test = 4.646;
      int zahl1 = 30, zahl2 = 23;
      test = halbiere(test);
      sagHallo();
      System.out.println("Wert: " + test);
      System.out.println("Wert: " + mittelwert(zahl1, zahl2));
      sagHallo();
   }

}

Die Methoden werden ganz normal in der "main"-Methode aufgerufen. Man muss darauf achten, dass man ihnen a) die richtige Anzahl an Parametern übergibt und b) für die Parameter auch den richtigen Datentyp wählt! Will man einen "float"- Wert an eine Methode übergeben, der wir aber laut Definition nur Integer übergeben dürfen, dann meckert der Compiler mal wieder.
Methoden ohne Rückgabewert brauchen logischerweise nicht in einen Ausdruck zur Weiterverarbeitung geschrieben werden, sondern können allein als einzelne Anweisung stehen. Man sieht außerdem an diesem Beispiel, dass Methoden Tipparbeit sparen, wenn sie mehrfach aufgerufen werden, v.a. wenn sie mehr als eine Anweisung verarbeiten. Die Übersichtlichkeit und Wartbarkeit des Quellcodes wird erhöht!
Da in der Kürze die Würze liegt, speichere ich den Rückgabewert der Methode "mittelwert" gar nicht mal mehr in einer eigenen Variable, sondern gebe ihn sofort in die "print"-Methode. Das ist deshalb legitim, weil die Funktion ja einen Integer zurückgibt: der Rechner setzt an die Stelle dann den Rückgabewert und verbindet ihn gleich mit dem String und schreibt es auf den Bildschirm. Praktisch!

nach oben