Wir haben schon (vielleicht ohne es zu bemerken) Methoden benutzt. Doch was genau sind Methoden und wofür sind sie gut?

Zunächst wollen wir die erste Frage versuchen zu beantworten - die Bedeutung und Notwendigkeit der Methoden sollte dann als eine Art Nebenprodukt klar werden…

Durch Methoden wird ausführbarer Code unter einem Namen zusammengefasst. Beim ausführen dieser Methoden wird dann der zusammengefasst Code ausgeführt. Dieser Code kann unter Verwendung von sogenannten (formalen) Parametern formuliert sein, denen später beim Aufruf der Methode Werte übergeben werden.

Methoden sind ein Bestandteil von Klassen. Wir befassen uns zunächst mit einem Spezialfall! Wichtiger ist allerdings die Behandlung von Methoden in Verbindung mit Objekten (später…)

Beispiel: mehrfache Auswertung der Funktion

`f(x) = x^2 + 2x - 4 `

Syntax:

<Berechtigung> <Rückgabetyp> <Methodenname> ( <Parameterliste> ) {
    <Anweisungen>
}

Berechtigung

1. public (default): Öffentlich, also auch für Objekte aus anderen Klassen zugänglich und ausführbar.
2. private: nicht öffentlich, nur Objekte dieser Klasse können die Methode ausführen.
3. protected: (später)

Rückgabetyp:
Das ist der Datentyp des Ergebnisses, das die Methode zurückliefern soll.

Man kann hier alle (Daten-)Typen, die man kennt, wählen. Falls keine Rückgabe erwünscht ist wählt man void.

Methodenname:
Bezeichner als Name für die Methode.

Parameterliste:
Eine Kommaliste von Variablendeklarationen (in runden Klammern).

Falls keine Parameter vorhanden sind, dann kommt nur "()". (runde Klammer auf und wieder zu) Die darin aufgeführten Variablen heißen formale Parameter.

Anschließend kommt der "Rumpf" der Methode (also die eigentliche Implementierung mit ihren Anweisungen).

Der Methodenkopf für die Berechnung von `f(x) = x^2 + 2x - 4 ` könnte lauten:

public static double f(double x)

Für die Ergebnisrückgabe an die aufrufende Umgebung steht die return-Anweisung zur Verfügung. Durch

    return ergebnis;

wird die Ausführung der Methode beendet und der Wert des Ausdrucks ergebnis als Resultat zurückgegeben.

Hat eine Methode den Rückgabetyp void, so lässt man return; in aller Regel weg (kann man auch hinschreiben, um zu verdeutlichen, dass die Methode dort beendet ist…)

Wichtig ist, dass eine Methode mehrere return-Anweisungen enthalten kann und darf ¹⁾.

Für Methoden, die nicht den Rückgabetyp void haben, muss aber sichergestellt sein, dass vor Beendigung der Methode eine return-Anweisung ausgeführt wird.

Beispielmethode komplett:

public static double f(double x) {
    double ergebnis = x*x + 2*x -4;
    return ergebnis;
}

Wie eine Methode aus BlueJ aufgerufen wird wissen wir bereits. Wie aber wird nun eine Methode aus dem Programm heraus aufgerufen? Recht simpel:

    Methodenname( Parameterliste );

    rueckgabe = Methodenname( Parameterliste );

public void sachTach(String name) {
    System.out.println("Tach " + name);
}

sachTach("Peter");

public int laenge(String name) {
    return name.length();
}

int i = laenge("Peter"); //also i = 5

i muss hier den selben Typ wie den Rückgabetypen der Methode haben, also int.

Folgendes sollte man auch noch im Hinterkopf behalten:

• Ein Methodenaufruf ist ein elementarer Ausdruck (wie ein Zuweisung, Variablendeklaration, Ausgabe…).
• Die Parameterliste ist eine Kommaliste von Ausdrücken (aktuelle Parameter in Form von Variablendeklarationen).
  Die Werte der Ausdrücke werden über die formalen Parameter aus der Methodendeklaration an die Methode übergeben.
• Nach dem Aufruf wird jeweils der entsprechende Rückgabewert für den ursprünglichen Methodenaufruf eingesetzt und mit diesem Wert weitergearbeitet.
• In Java erfolgt die Parameterübergabe stets als Wertaufruf (call by value). Es wird

stets eine Kopie des Wertes einer Variablen an die Methode übergeben, der Wert der Variablen bleibt unverändert.

In Java darf es auch innerhalb einer Klasse mehrere Methoden mit dem gleichen Namen geben, d.h. Methoden zu überladen:

public int max(int x, int y) {
    if (x>y) {
        return x;
    } else {
        return y;
    }
}
 
public double max(double x, double y) {
    if (x>y) {
        return x;
    } else {
        return y;
    }
}

Dabe unterscheidet Java Methoden gleichen Namens…

• anhand der Zahl der Parameter,
• anhand des Typs der Parameter und
• anhand der Position der Parameter.

Der Methodenkopf wird in diesem Zusammenhang auch Signatur²⁾ genannt.

Man darf in Methoden andere Methoden, aber auch sich selbst (also die eigene Methode) aufrufen. Diese letztgenannte Art nennt man Rekursion. Rekursion ist in Java erlaubt, d.h. Methoden dürfen sich selbst aufrufen!

Beispiel: Methode zur Berechnung der Fibonacci-Zahlen Fi:

`F0 = 0; F1 = 1; F_n = F_(n-1) + F_(n-2) ` für `n>=2 `

public int fibonacci(int n) {
    if ( n == 0 ){
        return 0;
    }
    if ( n == 1 ) {
        return 1;
    }

    return fibonacci(n-1) + fibonacci(n-2);
}

• Die Hauptmethode main ist nach dem gleichen Schema wie jede andere Methode aufgebaut.

public static void main(String[] args)

1. Erstelle die obige Tabelle in denen du je ein Beispiel zu den 4 möglichen Methodenköpfen (Signaturen) angibst.
2. Was berechnet die Methode max(int x, int y)?
3. Programmiere eine Mathode min(int x, int y).
4. Erstelle eine Klasse die den Benutzer nach drei Variablen a, b und c fragt und anschließend eine Methode quadFkt(double a, double b, double c) aufruft, die dann den Funktionswert von `f(x) = ax^2 + bx + c ` berechnet.
5. Programmiere eine Methode tausche(int x, int y), die den Inhalt zweier Variablen vertauscht.