Signatur einer Funktion und Funktionsüberladungen in Kotlin

Die Signatur einer Funktion in Programmierung stellt eine Art eindeutiges Identifikators einer Funktion dar. Durch die Verwendung der Funktionssignatur kann beispielweise eine Funktion in einer Gruppe von Funktionen mit demselben Namen eindeutig identifiziert und aufgerufen werden.

Die Funktionssignatur in Kotlin besteht immer aus dem Namen der Funktion sowie ihrer Parameterliste, einschließlich der Anzahl, Typen und Reihenfolge der Parameter, sowie dem Rückgabetyp.

Das folgende Beispiel veranschaulicht diese Ausführungen:

fun sumOfNumbers(a: Int, b: Int): Int {             // Die Signatur dieser Funktion lautet: sumOfNumbers(Int, Int) -> Int.
    return a + b
}
fun sumOfNumbers(a: Double, b: Double): Double {    // Die Signatur dieser Funktion lautet: sumOfNumbers(Double, Double) -> Double.
    return a + b
}
fun sumOfNumbers(a: Int, b: Double): Double {       // Die Signatur dieser Funktion lautet: sumOfNumbers(Int, Double) -> Double.
    return a + b
}

In diesem Beispiel haben drei Funktionen denselben Namen sumOfNumbers, aber unterscheiden sich in weiteren Bestandteilen der Signatur und dementsprechend werden vom Kotlin-Compiler eindeutig voneinander unterschieden und erkannt.

• Die Signatur der ersten Funktion lautet sumOfNumbers(Int, Int) -> Int, da sie zwei Parameter vom Typ Int hat und einen Int als Rückgabewert zurückgibt.
• Die Signatur der zweiten Funktion lautet sumOfNumbers(Double, Double) -> Double, da sie zwei Parameter vom Typ Double hat und einen Double als Rückgabewert zurückgibt.
• Die Signatur der dritten Funktion lautet sumOfNumbers(Int, Double) -> Double, da sie einen Parameter vom Typ Int und einen Parameter vom Typ Double hat und einen Double als Rückgabewert zurückgibt.

In Kotlin gibt es mehrere Anwendungsfälle, bei denen die Funktionssignatur verwendet wird. Einer davon ist die Überladung von Funktionen.

Funktionsüberladung

Durch die Verwendung unterschiedlicher Signaturen kann man Funktionen mit demselben Namen definieren, die aber unterschiedliche Aufgaben innerhalb eines Codes erfüllen. Diese Vorgehensweise wird als Funktionsüberladung (Engl.: Function Overloading) bezeichnet. Es ermöglicht Entwicklern, flexiblere, konsistentere und wiederverwendbare Codestrukturen zu schaffen und trägt zur Verbesserung der Lesbarkeit und Verständlichkeit des Codes bei.

Es gibt aber eine Besonderheit in Kotlin bei der Verwendung von Funktionssignaturen im Rahmen von Funktionsüberladungen. Bei Funktionsüberladungen wird nur der Name der Funktion sowie ihre Parameterliste, einschließlich der Anzahl, Typen und Reihenfolge der Parameter berücksichtigt. Der Rückgabetyp wird bei der Funktionsüberladung nicht berücksichtigt.

Anhand des nachstehenden Beispiels wird es gezeigt, wie Funktionsüberladung funktioniert:

fun main() {
val res1 = sumOfNumbers(5, 5)
println(res1)
val res2 = sumOfNumbers(5.5, 3.5)
println(res2)
val res3 = sumOfNumbers(10, 3.5)
println(res3)
}

fun sumOfNumbers(a: Int, b: Int): Int {         
    return a + b
}
fun sumOfNumbers(a: Double, b: Double): Double { 
    return a + b
}
fun sumOfNumbers(a: Int, b: Double): Double {  
    return a + b
}

In diesem Beispiel wurden drei Funktionen mit dem gleichen Namen sumOfNumbers deklariert, die unterschiedliche Signaturen aufweisen. Beim Aufruf der Funktion sumOfNumbers wählt der Compiler automatisch, abhängig vom Typ, der Anzahl und der Reihenfolge der Parameter die benötigte Version für die Ausführung aus. Der Rückgabetyp bleibt dabei unberücksichtigt. 

Um dies nachzuvollziehen, deklarieren wir jetzt zwei Funktionen, deren Signaturen sich nur im Rückgabetyp voneinander unterscheiden:

fun main() {
val res1 = sumOfNumbers(5, 5)
println(res1)
val res2 = sumOfNumbers(10, 20)
println(res2)
}

fun sumOfNumbers(a: Int, b: Int): Int {         // Vollständige Signatur: sumOfNumbers(a: Int, b: Int)-> Int
    return a + b
}
fun sumOfNumbers(a: Int, b: Int): String {      // Vollständige Signatur: sumOfNumbers(a: Int, b: Int)-> String
    return "$a + $b"
}

Für den Kotlin-Compiler im Rahmen der Funktionsüberladung werden beide Funktionen aufgrund der Berücksichtigung des Funktionsnamens, der Anzahl und Reihenfolge der Parameter als identisch betrachtet. Die Rückgabetypen Int und String werden dabei ignoriert. Als Resultat gibt der Compiler einen Fehler aus.