Bedingte Anweisungen

Bedingte Anweisungen sind in der Programmierung Konstrukte, die es ermöglichen, einen Programmablauf auf Basis von Bedingungen zu steuern. Die Bedingung kann beispielsweise auf eine bestimmte Variable oder den Zustand eines Programms verweisen. Wenn die Bedingung erfüllt ist, wird der Code innerhalb der bedingten Anweisung ausgeführt. Andernfalls wird der Code übersprungen oder ein alternativer Codeblock ausgeführt.

In Kotlin gibt es zwei Arten von bedingten Anweisungen: if-Anweisungen und when-Ausdrücke.

Die if-Anweisung ermöglicht eine Aktion auszuführen, wenn eine Bedingung wahr ist. Die Syntax der if-Anweisung ist ähnlich wie in anderen Programmiersprachen, aber es gibt einige Unterschiede.

Die allgemeine Syntax der if-Anweisung in Kotlin lautet wie folgt:

if (Condition) { // Condition = Bedingung
   // auszuführender Code-Block, wenn die Bedingung wahr ist
}

Hier ist ein einfaches Beispiel:

fun main() {
    val number: Int = 20

    if (number > 10) {
        println("The number is greater than 10")
    }
}

Dieser Code definiert eine Variable namens number mit dem Wert 10. Dann wird eine bedingte Anweisung mit der if-Anweisung eingeleitet. Die Bedingung lautet number > 5, was bedeutet, dass der Code-Block innerhalb der geschweiften Klammern nur ausgeführt wird, wenn die Variable number größer als 5 ist. In diesem Fall ist das der Fall, da number den Wert 10  hat, der größer als 5  ist. Daher wird der Code innerhalb der geschweiften Klammern ausgeführt und die Ausgabe „The number is greater than 5“ wird auf der Konsole gedruckt.

Wenn der Code-Block nur aus einem Ausdruck besteht, können die geschweiften Klammern im Grunde weggelassen werden:

fun main() {
    val number = 20

    if (number > 10)
    println("The number is greater than 10")
}

Die if-else-Anweisung ermöglicht, einen von zwei Code-Blöcken auszuführen, abhängig davon, ob eine Bedingung wahr oder falsch ist. Die Syntax der if-else-Anweisung in Kotlin lautet wie folgt:

if (Condition) {
    // Code-Block, der ausgeführt wird, wenn die Bedingung wahr ist
} else {
    // Code-Block, der ausgeführt wird, wenn die Bedingung falsch ist
}



fun main() {
    val age = 18

    if (age >= 18) {
        println("You are of legal age")
    } else {
        println("You are a minor")
    }
}

Dieser Code definiert eine Variable namens age mit dem Wert 18. Dann wird eine bedingte Anweisung mit der if-Anweisung eingeleitet. Die Bedingung lautet age >= 18, was bedeutet, dass der Code-Block innerhalb der geschweiften Klammern nur ausgeführt wird, wenn das Alter der Person 18 Jahre oder älter ist. In diesem Fall ist das der Fall, da age den Wert 18 hat, was bedeutet, dass die Person volljährig ist. Daher wird der Code innerhalb der ersten geschweiften Klammern ausgeführt und die Ausgabe „You are of legal age“ wird auf der Konsole gedruckt. Wenn die Bedingung falsch ist (d.h. das Alter der Person ist unter 18 Jahre), wird der Code innerhalb der else-Anweisung ausgeführt und die Ausgabe „You are a minor“ wird auf der Konsole gedruckt.

Die if-Anweisung kann auch einen Wert zurückgeben. Zum Beispiel können wir das Maximum von zwei Zahlen finden:

fun main() {
    val a = 5
    val b = 10

    val c = if(a > b) a else b
    println(c) // 10
}

Wenn zusätzliche Aktionen ausgeführt werden müssen, um den zurückgegebenen Wert zu bestimmen, können diese Aktionen in Code-Blöcken platziert werden:

fun main() {
    val a = 5
    val b = 10

    val c = if(a > b) {
        println("Variable a = $a")
        a
    } else {
        println("Variable b = $b")
        b
    }
}

Am Ende jedes Blocks wird der zurückgegebene Wert angegeben.

In Kotlin gibt es auch die if-else-if-Anweisung, die es ermöglicht, mehrere Bedingungen zu überprüfen und verschiedene Code-Blöcke auszuführen, abhängig von den Bedingungen. Die Syntax für die if-else-if-Anweisung lautet wie folgt:

   if (Condition1) {
      // Code-Block, der ausgeführt wird, wenn Bedingung1 wahr ist
   } else if (Condition2) {
      // Code-Block, der ausgeführt wird, wenn Bedingung2 wahr ist
   } else if (Condition3) {
      // Code-Block, der ausgeführt wird, wenn Bedingung3 wahr ist
   } else {
     // Code-Block, der ausgeführt wird, wenn keine der Bedingungen wahr ist
   }

Hier ist ein Beispiel für die Verwendung der if-else-if-Anweisung, um das Notensystem anhand der Punktzahl zu bestimmen:

fun main() {
    val score = 80

    if (score >= 90) {
    println("You have got A")
    } else if (score >= 80) {
    println("You have got B")
    } else if (score >= 70) {
    println("You have got C")
    } else {
    println("You have got F")
   }
}

when ist eine bedingte Anweisung in Kotlin, die es ermöglicht, eine Vielzahl von Bedingungen zu überprüfen und den entsprechenden Code-Block auszuführen, der mit der passenden Bedingung verknüpft ist.

when (variable) {
option1 -> {
      // Code-Block, der ausgeführt wird, wenn variable mit option1 übereinstimmt
}
option2 -> {
      // Code-Block, der ausgeführt wird, wenn variable mit option2 übereinstimmt
}
...
else -> {
      // Code-Block, der ausgeführt wird, wenn keine der Optionen übereinstimmt
}
}

Hier ist ein Beispiel für die Verwendung von when, um den Wochentag auf der Grundlage des Tages der Woche zu ermitteln:

fun main() {
    val dayOfWeek = 5

    when (dayOfWeek) {
         1 -> println("Monday")
         2 -> println("Tuesday")
         3 -> println("Wednesday")
         4 -> println("Thursday")
         5 -> println("Friday")  // "Friday" wird zurückgegeben
         6 -> println("Saturday")
         7 -> println("Sunday")
    else -> println("The day is not known")
    }
}

Vergleich mit Gruppe von Werten

Ein Vergleich kann mit einer Gruppe von Werten durchgeführt werden. Dabei ist es möglich, die gleichen Aktionen für mehrere dieser Werte zur selben Zeit zu definieren. In diesem Fall werden die Werte durch Kommas getrennt aufgelistet,

fun main() {
  val a: Int = 100

  when (a) {
       100, 200 -> println("Variable 'a' is 100 or 200") // Der String "Variable 'a' is 100 or 200" wird zurückgegeben
       else -> println("The value of the variable 'a' is unknown")      
  }
}

Man kann auch einen Wert mit einem ganzen Bereich von Werten vergleichen, indem man den in-Operator verwendet.

fun main() {
  val a: Int = 120

  when (a) {
      in 0..100 -> println("Variable 'a' is within the range of 0 to 100")
      in 101..200 -> println("Variable 'a' is within the range of 101 to 200") // a = 120 und liegt im Bereich 101 bis 200
      in 201..300 -> println("Variable 'a' is within the range of 201 to 300")
  }
}

Wenn der in-Operator es ermöglicht herauszufinden, ob ein Wert innerhalb eines bestimmten Bereichs liegt, so erlaubt die Kombination von Operatoren !in die Überprüfung, ob ein Wert nicht in einer bestimmten Sequenz enthalten ist.

fun main() {
    val a = 201

    when (a)  {
         in 0..100 -> println("Variable 'a' is within the range of 0 to 100")
         !in 101..200 -> println("Variable 'a' is NOT within the range of 101 to 200") // 201 ist nicht Bestandteil des Bereichs 101 bis 200
    }
}

when-Ausdruck und dynamisch berechnete Werte

Der when-Ausdruck kann auch mit dynamisch berechneten Werten verglichen werden.

fun main() {
    val a: Int = 50
    val b: Int = 30
    val c: Int = 20

    when (a) {
         b - c -> println("a = b - c")
         b + c -> println("a = b + c")  // 30 + 20 = 50, dementsprechend wird der String "a = b + c" ausgegeben
         else -> println("Undefined value")
    }
}

When kann außerdem auch ein dynamisch berechnetes Objekt entgegennehmen.

fun main() {
    val a: Int = 50
    val b: Int = 30

    when (a - b) {   // 50 - 30 = 20
         10 -> println("a - b = 10")
         20 -> println("a - b = 20")   // Der String "a - b = 20" wird ausgegeben
         else -> println("Undefined value")
    }
}

Es ist sogar möglich, Variablen zu definieren, die innerhalb des when-Ausdrucks verfügbar sein werden.

fun main() {
    val a: Int = 50
    val b: Int = 30

    when (val c: Int = a + b) {   // 50 + 30 = 80
         40 -> println("a + b = 40")
         60 -> println("a + b = 60")
         80 -> println("a + b = 80")   // c = 80, dementsprechend wird der String "a + b = 80" ausgegeben
         else -> println("Variable 'c' = $c")
    }
}

Die Konstruktion when kann auch als Alternative zum if..else eingesetzt werden. Dabei muss nicht unbedingt der Wert eines Objekts verglichen werden. Stattdessen wird eine Reihe von Bedingungen überprüft. Sobald eine der Bedingungen „true“ zurückgibt, wird der zugehörige Satz von Anweisungen ausgeführt.

fun main() {
    val a: Int = 50
    val b: Int = 50

    when {
         (a > b) -> println("a > b")
         (a < b) -> println("a < b")
         (a == b) -> println("a = b") // 50 = 50, dementsprechend wird der String "a = b" ausgegeben
    }
}

Ähnlich wie if-Konstrukt kann der when-Ausdruck einen Wert zurückgeben. Das zurückgegebene Ergebnis wird durch den Pfeiloperator -> definiert.

fun main() {
    val a: Int = 50
    val b: Int = 50

    val sum: Int = a + b // 50 + 50 = 100
    val result: Int = when(sum) {
        in 0..99 -> 0
        in 100..199 -> 1 // Wert der Variable "sum" liegt im Bereich 100..199, dementsprechend wird der Wert "1" zurückgegeben
        else -> 2
    }
    println(result)
}