Funktionen in Kotlin

Eine Funktion ist ein Teil eines Programms, der eine spezifische Aufgabe oder Berechnung ausführt und gegebenenfalls ein Ergebnis zurückgibt. Funktionen dienen dazu, den Code in logische Einheiten zu unterteilen, was es ermöglicht, den Code wiederverwendbar und übersichtlich zu gestalten.

In anderen Worten eine Funktion kann als eine Art „Unterprogramm“ betrachtet werden, das bestimmte Aufgaben innerhalb eines größeren Programms ausführt und das Ergebnis dieser Aufgaben an das Hauptprogramm zurückgeben kann. Es hilft, den Code modular zu gestalten, indem es wiederholte Aufgaben in einer einzigen Funktion zusammenfasst, die an mehreren Stellen im Programm aufgerufen werden kann.

In Kotlin ist die Syntax einer Funktion wie folgt definiert:

fun functionName (parameter1: Type, parameter2: Type, parameter3: Type, etc.) : ReturnType {  
    code to run     
    return expression                                                        
}

• Das Schlüsselwort fun wird verwendet, um eine Funktion zu deklarieren.
• Anschließend folgt der Name der Funktion.
• Die Parameter sind Platzhalter und dienen dazu, Daten oder Werte (auch Argumente genannt) an die Funktion zur Bearbeitung zu übergeben. Funktionsparameter werden in Klammern geschrieben und jeder Parameter hat einen Namen und einen Typ. Mehrere Parameter werden durch Kommas getrennt. Die Definition von Parametern ist optional.
• Falls die Funktion einen Rückgabewert hat, kann nach der Liste der Parameter der Rückgabetyp angegeben werden. Wenn kein Rückgabetyp angegeben wird, wird die Funktion als Funktion vom Typ Unit angesehen.
• Schließlich  in den geschweiften Klammern befindet sich der Funktionskörper (Function body) – der Code, der beim Aufruf der Funktion ausgeführt wird und die eigentliche Aufgabe erledigt.
• Wenn eine Funktion einen Wert zurückgeben soll, kann das Schlüsselwort return verwendet werden, um den Wert an den Aufrufer zu übergeben.

Hier ist ein Beispiel einer Funktion, die zwei Zahlen addiert und das Ergebnis zurückgibt:

fun main() {
    fun additionOfNumbers (a: Int, b: Int): Int {   // Deklaration der Funktion mit Parametern und dem Rückgabetyp
        return a + b                                // Funktionskörper mit dem Code, der Berechnung ausführt und das Ergebnis zurückgibt
    }

    // Nachdem die Funktion 'additionOfNumbers' einmalig definiert wurde, kann sie an verschiedenen Stellen im Programm
    // mithilfe ihres Namens mehrfach aufgerufen werden, um Berechnungen mit unterschiedlichen Zahlen (Parametern) durchzuführen.

    val result1: Int = additionOfNumbers(5,5)       // Aufruf der Funktion und Übergabe von zwei Parametern '5' und '5' an die Funktion
    println(result1)                                // Ausgabe des Resultats in der Konsole
    val result2: Int = additionOfNumbers(10,15)     // Hier rufen wir die gleiche Funktion noch einmal auf und übergeben an sie die Parameter '10' und '15'
    println(result2)                                // Ergebnis: 25
}

Organisation von Funktionen innerhalb eines Programms

Die main()-Funktion haben wir bereits am Anfang des Tutorials kennengelernt und nutzen diese seitdem regelmäßig in den Beispielen und Übungsaufgaben. Dies ist notwendig, um den Kotlin-Code überhaupt ausführen zu können.

Kurze Erinnerung: Die Funktion main() in Kotlin ist die Hauptfunktion eines Kotlin-Programms. Es ist der Einstiegspunkt des Programms und wird bei dessen Ausführung  zuerst aufgerufen.

Bis jetzt haben wir unsere Funktionen immer innerhalb der Hauptfunktion main() platziert, was auch sinnvoll sein kann, um bestimmte Funktionalitäten in der main()-Funktion zu gruppieren und zu organisieren. In der Softwareentwicklung, insbesondere bei komplexeren Anwendungen, ist es jedoch üblich, Funktionen auf eine logische und übersichtliche Art und Weise zu organisieren, indem man sie unter anderem als selbstständige Funktionen (top-level functions) sowohl außerhalb der main()-Funktion als auch außerhalb von Klassen definiert oder sogar in eine separate Datei auslagert. Diese Funktionen werden innerhalb der Hauptfunktion nur aufgerufen, wenn sie wirklich benötigt werden. 

Jetzt organisieren wir den Code des vorherigen Beispiels entsprechend um:

fun main() {
    val result1: Int = additionOfNumbers(5,5)    // Der erste Aufruf der Funktion innerhalb der main()-Funktion   
    println(result1)                               
    val result2: Int = additionOfNumbers(10,15)  // Der zweite Aufruf der Funktion innerhalb der main()-Funktion      
    println(result2)                              
}

// Deklaration der Funktion außerhalb der main()-Funktion. Der Code kann auch in eine separate Datei ausgelagert werden.
fun additionOfNumbers (a: Int, b: Int): Int {   
        return a + b                          
}

Ab jetzt werden wir öfter solche Schreibweise nutzen.

Funktionen ohne Parameter

Eine Funktion ohne Parameter ist eine Funktion, die keine Eingabedaten benötigt, um ihre Aufgabe auszuführen. In der Kotlin-Syntax werden solche Funktionen ohne Parameterliste deklariert (Die Klammern bleiben leer functionName() ).

Zum Beispiel können wir eine Funktion definieren und aufrufen, die einfach eine bestimmte Zeichenkette auf der Konsole ausgibt:

fun main() {
    sayHelloWorld()               // Der erste Aufruf der Funktion
    sayHelloWorld()               // Der zweite Aufruf der Funktion
    sayHelloWorld()               // Der dritte Aufruf der Funktion
}

fun sayHelloWorld() {            // Deklaration der Funktion ohne Parametern
    println("Hello World!")      // Funktionskörper mit dem Code, der die Zeichenkette 'Hello World!' ausgibt
}

In dem vorherigen Beispiel hat die Funktion sayHelloWorld keine Parameter, sondern gibt lediglich einen Text auf der Konsole aus.

Parameter können unterschiedliche Datentypen innerhalb einer Funktion haben

In Kotlin können Funktionen Parameter mit verschiedenen Datentypen besitzen. Diese Flexibilität ermöglicht es, Funktionen zu schreiben, die eine Vielzahl unterschiedlicher Dateneingaben verarbeiten kann.

Zum Beispiel kann eine Funktion einen String-Parameter, einen Integer-Parameter und einen Boolean-Parameter haben. Hier ist ein Beispiel:

fun main() {
// Funktion wird drei Mal aufgerufen
    userInformation("Max", 22, true)     
    userInformation("Julia", 29, true)
    userInformation("Mickey", 50, false)  
}

// Deklaration der Funktion mit drei unterschiedlichen Datentypen von Parametern
fun userInformation(userName: String, userAge: Int, paidAccount: Boolean) {  
    println("Name: $userName,  Age: $userAge,  Paid account: $paidAccount")
}

Default-Argumente für Funktionsparameter

Default-Argumente sind vordefinierte Werte für Funktionsparameter. Wenn ein Funktionsaufruf keinen Wert für einen bestimmten Parameter angibt, verwendet die Funktion stattdessen den Default-Wert für diesen Parameter. Diese Default-Werte können in der Funktionsdefinition angegeben werden und erleichtern es Entwicklern, die Funktionen flexibler und wiederverwendbarer zu gestalten.

Die Syntax für die Verwendung von Default-Argumenten für Funktionsparameter ist wie folgt:

• Beim Definieren der Funktion wird dem Parameter ein Default-Argument mithilfe des Gleichheitszeichens = zugewiesen.

Folgendes Beispiel zeigt die Verwendung von Default-Werten in Kotlin:

fun main() {
    userInformation("Max", 22)                          // Aufruf der Funktion mit den Default-Argumenten 'Newbie' und 'false'   
    userInformation("Julia", 29, "Beginner", true)      // Aufruf der Funktion mit Übergabe von eigenen Argumenten 'Beginner' und 'true'
    userInformation("Mickey", 50, "Experienced", true)  // Aufruf der Funktion mit Übergabe von eigenen Argumenten 'Experienced' und 'true'  
}

fun userInformation(userName: String, userAge: Int, userLevel: String = "Newbie", paidAccount: Boolean = false) { // Zuweisung von Default-Werten: userLevel = 'Newbie', paidAccount = false  
    println("Name: $userName,  Age: $userAge,  User Level: $userLevel,  Paid account: $paidAccount")
}

Benannte Argumente

Die Übergabe der Werte an die Parameter erfolgt standardmäßig gemäß ihrer Position: Der erste Wert wird dem ersten Parameter, der zweite Wert dem zweiten Parameter usw. übergeben. Durch die Verwendung benannter Argumente kann die Übergabereihenfolge geändert werden. Das macht man, indem beim Funktionsaufruf innerhalb der Klammern den Namen des Parameters angibt und seinen Wert mithilfe des Gleichheitszeichens übergibt.

fun main() {
    userInformation(userLevel = "Newbee", userName = "Max", userAge = 22) 
    userInformation(userAge=29, userLevel="Beginner", userName="Julia", paidAccount=true)    
    userInformation("Mickey", 50, paidAccount=true, userLevel="Experienced")
}

fun userInformation(userName: String, userAge: Int, userLevel: String = "Newbie", paidAccount: Boolean = false) { // Zuweisung von Default-Werten: userLevel = 'Newbie', paidAccount = false  
    println("Name: $userName,   Age: $userAge,  User Level: $userLevel,  Paid account: $paidAccount")
}

Es ist nicht notwendig, alle Argumente über den Namen zu übergeben. Ein Teil der Argumente kann auch über die Position übergeben werden. Wenn jedoch ein Argument über den Namen übergeben wurde, müssen alle nachfolgenden Argumente ebenfalls über den Namen des entsprechenden Parameters übergeben werden.

Wenn vor einem obligatorischen Funktionsparameter optionalen Parameter liegen, dann muss für den obligatorischen Parameter ein Wert unter Verwendung seines Namens übergeben werden.

fun main() {
    userInformation(userName="Max")    
    userInformation(userName="Mickey", userLevel="Experienced")       
}

fun userInformation(userLevel: String = "Newbie", userName: String) { 
    println("User Level: $userLevel,   Name: $userName")
}

Änderung von Funktionsparametern

In Kotlin werden Funktionsparameter standardmäßig als val Variablen deklariert, das bedeutet, dass ihr Wert nicht verändert werden kann. Wenn man versucht, den Wert eines solchen Parameters innerhalb der Funktion zu ändern, wird ein Fehler ausgelöst. Hier ein Beispiel:

fun main() {
    fun doubleValue(value: Int) {
        value = value * 2   // Fehler, da Parameter 'value' uveränderbar ist
        println("Value inside the function: $value")
    }
}

Wenn man jedoch ein komplexes Objekt, wie z.B. ein Array, als Funktionsparameter übergibt, kann man dessen Inhalte innerhalb der Funktion ändern. Nachstehend ist ein Beispiel:

fun main() {
    val numbers = intArrayOf(4, 5, 6)
    doubleFirstElement(numbers)
    println("Doubled value of the first element is: ${numbers[0]}")
}

fun doubleFirstElement(numbers: IntArray) {
    numbers[0] = numbers[0] * 2
}