Elementare Kontrollstrukturen

Stand: 11. August 2019

• if, else
• while, do while
• for
• match

if, else

Die if, else - Kontrollstruktur arbeitet wie in den meisten anderen Programmiersprachen. Eingeleitet wird die Kontrollstruktur mit dem Schlüsselwort if, worauf in runden Klammern ein Ausdruck erwartet wird, der als Rückgabewert ein Boolean liefert. Hat der Rückgabewert den Wert true, wird der Ausdruck, der dem if folgt ausgeführt. Andernfalls wird der Ausdruck, der einem optionalen else folgt ausgeführt.

if (op.equals('-')) println("Minus")
else if (op.equals('+')) println("Plus")
else println("None")

Sollen mehrere Anweisungen je nach Rückgabewert des Boolean Ausdrucks zusammen ausgeführt werden, können diese mithilfe geschweifter Klammern zu einer Block-Anweisung zusammengefasst werden.

def control(op: Char, value1: Int, value2: Int) {
  if (op.equals('-')) {
    println("Minus")
    value1 - value2
  }
  else if (op.equals('+')) {
    println("Plus")
    value1 + value2
  }
  else println("None")
}

In Scala hat die if, else - Kontrollstruktur einen Rückgabewert. So kann in Scala der Inhalt einer Variablen von einer Bedingung abhängig gemacht werden. Im nachfolgenden Beispiel wird die Variable check in Abhängigkeit der Variablen checkValue mit "gerade" oder "ungerade" belegt.

object MainObject {
  def main(args: Array[String]){
    val ifExample = new IfExample()
         
    ifExample.checkTheValue(3)
    ifExample.checkTheValue(2)
  }
}
          
class IfExample {
          
  def checkTheValue(checkValue: Int) {
    val check = if (checkValue % 2 == 0) "gerade"
                else "ungerade"
         
    println("checkValue "+checkValue+" ist "+check)
  }
}

while, do while

while Schleifen werden mit dem Schlüsselwort while eingeleitet dem ein Ausdruck, in runden Klammern folgt. Das Ergebnis dieses Ausdruckes muss vom Typ Boolean sein. Ist der Wert des Ausdruckes true, wird die Anweisung (Blockanweisung), die nach der runden Klammer folgt, ausgeführt. Ist der Wert des Ausdruckes false, wird die nachfolgende Anweisung nicht ausgeführt.

object MyWhile {
  def main(args: Array[String]) {
    var index = 0;
    while (index < args.length) {
      println(args(index))
      index += 1
    }
  }  
}

Bei der while Schleife wird vor dem ersten Durchlauf geprüft, ob der Ausdruck true ergibt. Daraus folgt, dass der Schleifeninhalt nicht unbedingt ausgeführt werden muss.

Bei der do while Schleife wird hingegen die Prüfung am Ende des Schleifeninhaltes vorgenommen. Daraus folgt, das der Schleifeninhalt zumindest einmal ausgeführt wird.

object MyDoWhile {
  def main(args: Array[String]) {
    var index = 0;
    do{
      println(args(index))
      index += 1
    }while (index < args.length)
  }  
} 

Beide oben vorgestellten Programme geben die an das Programm übergebene Parameter aus. Sollte im Falle von MyDoWhile keine Parameter an das Programm übergeben werden, wird zur Laufzeit eine ArrayIndexOutOfBoundsException geworfen.

Beide Formen der while, do while Schleifen liefern in jedem Fall Unit als Ergebnis des Ausdruckes. Die allgemeine Schreibweise für Unit ist: ()

for

Die for Schleife in Scala ist zu weitaus mehr geeignet, als Zahlenbereiche zu durchlaufen. Aber zunächst soll dies als erstes Beispiel für die for Schleife in Scala dienen.

Die Ausführung der nachfolgenden for Schleife gibt die Zahlen 1 bis 10 aus.

for (i <- 1 to 10) println(i)  

match

match ist das Scala Gegenstück zu Java's switch, wenn auch weit aus mächtiger und als Pattern Matching bezeichnet. Mit Hilfe von match können in Scala auch Objekte zur Fallbestimmung herangezogen werden. Nachfolgend ein Beispiel, wo Int-Objekte zur Fallunterscheidung herangezogen werden:

val iValue = 3
iValue match{
  case 1 => println("eins")
  case 2 => println("zwei")
  case 3 => println("drei")
  case 4 => println("vier")
  case 5 => println("fuenf")
  case _ => println("nothing")
}

Wird dieses Script ausgeführt, wird auf der Systemausgabe die Ausgabe drei ausgegeben.

Einem Java Programmierer könnte auffallen, dass vier und fuenf nicht ausgegeben werden. In Scala wird die Angabe von einem break implizit vorgenommen. Ein sogenanntes "fall through" kommt demnach nicht vor.

Das "default" wird in Scala mit einem Unterstrich angegeben. _ entspricht in Scala dem Wildecard (Platzhalter) für unbekannte Werte. Ein weiterer Unterschied zu Javas switch ist, dass in einem match Ausdruck ein case "treffen" muss. Trifft kein case zu, wird ein MatchError geworfen.