Funktionen mit Parameter

---

Mit while-Schleifen können wir bereits Funktionen wie „nimmZwei()“, „nimmDrei()“ oder „nimmSieben()“ programmieren. Die Anzahl der Schleifendurchläufe ist der einzige Unterschied, ansonsten sind die Funktionen gleich.
Mit Parametern kann man nun eine Funktion „nimmAnz(int anzahl)“ definieren, die Parameter stehen in den runden Klammern. Beim Aufrufen der Funktion wird dann bestimmt, wie viele Körner der Hamster nehmen soll.

void nimmAnz(int anzahl) {         // VARIANTE 1
    while ((anzahl > 0) && kornDa()) {
        nimm();
        anzahl–;
    }
}

void main() {
    nimmAnz(4);

    vor();
    int anz = 6;
    nimmAnz(anz);
}

 

Die Variable „anzahl“ in der Funktionsdefinition wird auch „formaler Parameter“ genannt. Beim ersten Aufruf in main() „nimmAnz(4)“ spricht man vom „aktuellen Parameter“ 4 – der Variablen „anzahl“ wird der Wert 4 übergeben.
Beim zweiten Aufruf „nimmAnz(anz)“ wird die Variable „anz“ übergeben, der Wert „6“ wird dabei in die Variable „anzahl“ kopiert. Durch das Kopieren stellt man sicher, dass sich die Variable „anz“ nicht verändert, obwohl die Variable „anzahl“ in der Funktion vermindert wird („call-by-value“).

Es ist auch möglich, Funktionen mit Rückgabewert als aktuelle Parameter zu verwenden. Dabei wird zuerst der Rückgabewert berechnet, dann wird dieser als aktueller Parameter übergeben.

int meinMinimum() {
    return 3;
}

int berechneAnz(int a) {
    return a*2 + 1;
}
…

void main() {
    nimmAnz(meinMinimum());
    nimmAnz(berechneAnz(3));
}

 

Mehrere Parameter:

Bei einer Funktionsdefinition kann man auch mehrere Parameter, durch Komma getrennt, festlegen.

void nimmAnz(int anzahl, boolean gehWeiter) {    // VARIANTE 2
    int n = 0;
    while ((n < anzahl) && kornDa()) {
        nimm();
        n++;
    }
    if (gehWeiter) {
        vor();
    }
}

 

Es ist möglich, mehrere Funktionen mit dem gleichen Namen zu definieren, solange sich die Parameterlisten unterscheiden. Dazu muss es eine unterschiedliche Anzahl an Parametern geben oder die Parameter müssen sich an mindestens einer Stelle in ihrem Typ unterscheiden. Die Reihenfolge der Parameter muss beim Aufrufen der Funktion eingehalten werden. Der Compiler erkennt dann, welche Funktion verwendet werden soll.

  nimmAnz()                          // Fehler beim Funktionsaufruf, Parameter wird erwartet

   nimmAnz(4)                        // ok! (Variante 1)

   nimmAnz(true)                 // Fehler beim Funktionsaufruf, integer wird erwartet

   nimmAnz(true, 4)             // Fehler, Reihenfolge der Parameter ist vertauscht (Variante 2)

 

Beliebig viele Parameter:

Für beliebig viele Parametern kann man drei Punkte an den Parametertyp in der Funktionsdefinition anhängen. Die Anzahl der beim Aufruf übergebenen aktuellen Parameter erhält man, indem man an den Variablennamen „.length“ anghängt. Für den Zugriff auf die einzelnen Werte benutzt man eckige Klammern und einen Index. Ein solcher Parameter muss in der Definition an letzter Stelle stehen.

int produkt(int… faktoren) {
    int prod = 1;
    int i = 0;
    while (i < faktoren.length) {
        prod *= faktoren[i];
        i++;
    }

    return prod;
}

void main() {
    int p1 = produkt(3, 4);
    int p2 = produkt(6, 5, 4, 3, 2);
}

---