Der Programmablauf (oder Kontrollfluss) eines Computerprogramms beschreibt die zeitliche Abfolge der Ausführung der Befehle. In einem einfachen Programm werden die Befehle von oben nach unten (Zeilen 1, 2, 3, …) abgearbeitet.

Es existieren aber sog. Kontrollstrukturen, welche eine Abweichung von diesem Ablauf bereits zur Programmierzeit ermöglichen (es gibt auch Möglichkeiten, den Ablauf eines Programms zur Ausführungszeit zu beeinflussen [etwa zu unterbrechen und später fortzusetzen]).

Kontrollfluss

Während der Erstellung des Programms kann man zwischen Verzweigungen und Schleifen wählen, um Einfluss auf den Kontrollfluss zu nehmen. Conditionals, oder bedingte Anweisungen ermöglichen Verzweigungen. Hier kann man den Programmcode nach der Auswertung einer sogenannten Bedingung aufteilen.

Bedingungen / Boolesche Ausdrücke

Bedingungen sind Ausdrücke, die man in true oder false auswerten kann (sog. Boolesche Ausdrücke). Je nachdem, wie die Auswertung ausfällt, kann man unterschiedliche Befehle definieren, welche in diesem (true) oder jenem (false) Fall ausgeführt werden sollen. Man kann dies elegant in den Nassi-Shneiderman-Diagrammen (oder Struktogramme) visualisieren.

Video

Boolesche Vergleichs-Operatoren

Ausdruck	Überprüft auf
==	Gleichheit
!=	Ungleichheit
>	Größer
<	Kleiner
>=	Größer gleich
<=	Kleiner gleich

Beispiele zu Vergleichsoperatoren

fun main(){
	val value1 = 8 
	val value2 = 5 
	println("value1 == value2 : ${value1 == value2}") 
	println("value1 != value2 : ${value1 != value2}") 
	println("value1 < value2 : ${value1 < value2}")
	println("value1 > value2 : ${value1 > value2}") 
} 

Boolesche Kombinations-Operatoren

Ausdruck	Wird ausgewertet in
true	true
false	false
!true	false
!false	true
true && true	true
true && false	false
false && true	false
false && false	false
true || false	true
false || true	true
false || false	false

Beispiele zu Kombinationsoperatoren

fun main(){ 
	val booleanValue1 = true 
	val booleanValue2 = true
	println("booleanValue1 == booleanValue2 (Gleich): ${booleanValue1 == booleanValue2}") 
	println("booleanValue1 != booleanValue2 (Ungleich): ${booleanValue1 != booleanValue2}")
	println("booleanValue1 && booleanValue2 (Und): ${booleanValue1 && booleanValue2}") 
	println("booleanValue1 || booleanValue2 (Oder): ${booleanValue1 || booleanValue2}")
	
	val value3 = 0 
	val value4 = 18 
	
	val booleanValue3 = value3>value4
	println("Wert von booleanValue3: $booleanValue3") }

Anweisungen oder Ausdrücke?

Die Überschrift dieses Kapitels lautet "bedingte Anweisungen", allerdings handelt es sich bei den if und when-Befehlen in Kotlin um Ausdrücke! Eine Anweisung ist nichts anderes als ein Code-Schnipsel, der dem Computer sagt, was er tun soll:

fun main(){
//sampleStart
println("Das ist eine Anweisung") 
//sampleEnd
}

Ein Ausdruck hingegen, besitzt ein Ergebnis, welches zugewiesen werden kann:

fun main(){
//sampleStart
val x = 3 + 5 // Das ist ein Ausdruck
//sampleEnd
}

Wenn if- und when-Befehle also Ausdrücke sind, können wir sie auch wie folgt handhaben:

fun main(){
    val x = 5
    val y = 4
    val z = 9
    println(istXgroesserY(x,y))    
    println(sindXoderYgroesserZ(x,y,z))
}

fun istXgroesserY(x : Int, y : Int) = x > y

fun sindXoderYgroesserZ(x : Int, y : Int, z : Int) : Boolean {
    return when{
    		z < x -> true
    		z < y -> true
            else -> false
            }
}