Kotlin (Programmiersprache)

fun main() {                          // Einsprungpunkt (Main-Funktion)
    println("Hallo Welt!")            // Gib den String 'Hallo Welt!' aus
}

// Definition einer Funktion "funktionsBeispiel"
fun funktionsBeispiel() {
// ...
}

// Funktion mit zwei Argumenten und einem Rückgabewert
fun add(x: Int, y: Int): Int {
    return x + y
}

// Besteht eine Funktion aus nur einem Ausdruck, dürfen die geschweiften Klammern, der Rückgabetyp und das "return" weggelassen werden.
fun add2(x: Int, y: Int) = x + y

// Einsprungpunkt (Main-Funktion)
fun main(args: Array<String>) {
    // Definition einer verschachtelten Funktion, die nur in main aufgerufen werden kann.
    fun test() {
        println("Hello World!")
    }
    // Aufrufen der Funktion
    test()
}

// Weist der schreibgeschützten lokalen Variable 'x' die Tastatureingabe (standard input stream) als Integer-Wert zu.
val x = readLine()!!.toInt()

// if..else-Anweisung, die prüft ob der Integer-Wert größer, kleiner oder gleich null ist.
// Mit Ausgabe von Text auf der Konsole.
if (x > 0) print("positiv") else if (x < 0) print("negativ") else print("null")

// Int-Eingabe: 10 -> String-Ausgabe: positiv

//  Weist der schreibgeschützten lokalen Variable 'x' die Tastatureingabe (standard input stream) als Integer-Wert zu.
val x = readLine()!!.toInt()

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    3, 4 -> print("x == 3 oder x == 4")
    in 5..7 -> print("x zwischen 5 und 7")
    else -> print("x ist kleiner als 1 oder größer als 7.")
}

// Wiederholt die Funktionsanweisung 2x
repeat(2) {
    println("Hello Wiki")
}
// Hello Wiki
// Hello Wiki

// Iteriert i innerhalb der 7-downTo-1-Range in Zweierschritten
for (i in 7 downTo 1 step 2) print("$i ")
// 7 5 3 1

// Funktion, die eine andere Funktion entgegennimmt
fun callWithInt(number: Int, fn: (Int) -> Int) {
    val result = fn(number)
    println(result)
}

// Funktion, die eine andere Funktion zurückgibt
fun makeAdder(a: Int): (Int) -> Int {
    fun add(b: Int) = a + b
    return ::add
}

// Anders als in Java dürfen in Kotlin Closures auf Variablen auch schreibend zugreifen
var number = 0
fun makeCounter(): () -> Int {
    fun counter() = ++number
    return ::counter
}

fun double(x: Int) = x * 2

fun main() {
    // Aufruf mit Funktionszeiger
    callWithInt(42, ::double)

    // Aufruf mit anonymer Funktion
    callWithInt(42, fun(x: Int) = x * 2)

    // Aufruf mit Lambda-Ausdruck
    callWithInt(42, { x -> x * 2})

    // Als letztes Argument dürfen Lambdas außerhalb der runden Klammern geschrieben werden.
    // Wenn die Funktion nur ein Argument erwartet, heißt dieses "it", falls nicht anders festgelegt.
    callWithInt(42) { it * 2 }

    val add2 = makeAdder(2)
    println(add2(5)) // gibt 7 aus

    val counter = makeCounter()
    println(counter()) // Gibt 1 aus
    println(counter()) // Gibt 2 aus
}

val list = setOf(1, 2, 3, 4, 5)

println(list.map { it * 2 }) // [2, 4, 6, 8, 10]
println(list.filter { it > 2 }) // [3, 4, 5]
println(list.groupBy { it % 2 }) // {1=[1, 3, 5], 0=[2, 4]}

val cities = listOf("Berlin", "Hamburg", "München", "Köln", "Frankfurt")

// Die Anfangsbuchstaben der drei Städte mit den kürzesten Namen hintereinander
val result = cities
    .sortedBy { it.length }
    .take(3)
    .map { it[0] }
    .fold("") { acc, char -> acc + char }

println(result) // KBH

// Erstellt eine Variable vom Typ "Int" (darf nicht "null" sein)
var a: Int = 123

// Erstellt eine Variable, die den Wert "null" annehmen darf.
var b: Int? = 456

// Nicht erlaubt (Erzeugt einen Kompilierfehler)
a = null

// Zugelassen
b = null

fun nullSafety() {
    val test: String? = "Test"

    // Kompilierfehler (könnte "Null Pointer Exception" verursachen)
    println(test.length)

    // Erlaubt, da auf null abgeprüft wird.
    if (test != null)
        println(test.length)

    // Auch erlaubt (zweite Bedingung wird nur überprüft, wenn die erste falsch ist)
    if (test == null || test.length == 0)
        println("Leerer String")

    // Ebenfalls erlaubt
    if (test == null)
        return

    println(test.length)
}

val ort = kunde?.adresse?.ort
val ortOderLeer = ort ?: ""

// Obiger Code ist gleichbedeutend mit:

val ort: String?
if (kunde == null || kunde.adresse == null)
    ort = null
else
    ort = kunde.adresse.ort

val ortOderLeer: String
if (ort == null)
    ortOderLeer = ""
else
    ortOderLeer = ort