Der Weg zum Full-Stack-Developer

Variablen
Methoden
Verzweigungen
Schleifen

Variablen

val ganzeZahl: Int = 42
val reelleZahl: Double = 3.14
val zustand: Boolean = false
val zeichenfolge: String = "Hallo Welt"

var zaehler = 0
zaehler += 1
println(zaehler) // gibt 1 zurück

Scala bietet die Möglichkeit Variablen unveränderlich mit val oder veränderlich mit var zu definieren. Das bedeutet, dass man einem val (auch Value ausgesprochen) einmalig einen Wert zuweist und diesen nicht mehr ändern kann. Bei var (auch Variable ausgesprochen) kann man im Laufe des Programms neue Werte zuweisen solange es der gleiche Datentyp bleibt.
In der Regel benutzen wir immer val, wenn wir uns nicht sicher, ob man diese Variable irgendwann ändern möchte. Das hat sich als guter Programmierstil herausgestellt.

Die gängigsten Datentypen sind Integer, Double, Boolean und String (siehe Code-Beispiel oben). Scala ist streng-typisiert, d.h. eine Variable behält immer seinen Datentyp, also kann man zum Beispiel keine Zeichenfolge einer Variable zuweisen, die vorher als ganze Zahl deklariert war.

Methoden

def rabatt(preis: Double, rabatt: Double): Double = {
    val faktor = rabatt / 100
    preis * (1 - faktor)
  }
def quadrat(x: Int): Int = x * x
def gruesse(name: String): Unit = println("Hallo " + name)

println("10% Rabatt auf 200 Euro ergibt: " + rabatt(200, 10))
println("Das Quadrat von 12 ist: " + quadrat(12))
gruesse("Helmut")

Methoden werden mit dem Schlüsselwort def deklariert. Dann folgt der Methodenname und in Klammern eine Liste mit Argumenten, die mit Kommata getrennt sind. Anschließend ein Doppelpunkt und der Datentyp des Rückgabewertes gefolgt von einem Gleichzeichen. Geht der Inhalt der Methode über mehrere Zeilen, so kreiert man einen Block mit geschweiften Klammern um sie (siehe Codebeispiel oben). Eine Methode, die nichts zurückgibt, bekommt den Datentyp Unit, welchen wir in einem anderen Kapitel näher kennen lernen werden.
Aufrufen kann man die Methode in dem man den Methodennamen und dessen Argumente in Klammern schreibt. Methoden nutzt man vor allem, wenn man mehrere Zeilen Code mehrmals ausführen möchte. Das Copy&Paste ist in der Programmierung nicht gern gesehen.

Verzweigung – if-Statement

if (x < 0) println("Zahl ist kleiner 0 und somit nicht im Intervall [0,10]")
    else if (x > 0) println("Zahl ist größer 10 und somit nicht im Intervall [0,10]")
    else {
      // richtige Zahl angebeben
      println("Zahl liegt im Intervall [0,10]")
    }

Oft ist man in der Situation, dass das Program entweder dies oder das tun soll, wofür man Verzweigungen und Bedingungen benutzt. Bei der Verzweigung, hier am Beispiel des if-statemantes, beginnen wir mit einem if gefolgt von einer Bedingung in Klammern. Bedingen können sein:

• == gleich
• < kleiner
• > größer
• != ungleich
• <= kleiner gleich
• >= größer gleich

Anschließend kann man optional ein else if mit einer weiteren Bedingung in Klammern anfügen oder auch optional ein else ohne Bedingung und Klammern. else trifft immer auf die Fälle zu, die durch if bzw. else if nicht abgedeckt sind.
Auch hier gilt, gehen die Anweisungen über mehrere Zeilen setzt man mit den geschweiften Klammern {} einen Block.

Es ist auch möglich Bedingungen zu negieren und mit Und/Oder zu verknüpfen.

A	B	!(A)	!(B)	A||B	A && B	!(A) && B
0	0	1	1	0	0	0
0	1	1	0	1	0	1
1	0	0	1	1	0	0
1	1	0	0	1	1	0

Wobei 0 für falsch bzw. false steht und 1 für wahr bzw. true.
! steht für nicht, && für und, || für oder.
In Code geschrieben:

(true && true) == true
(true && false) == false
(false && false) == false

(true || true) == true
(true || false) == true
(false || false) == false

!(false) == true
!(true) == false

Schleifen

Möchte man Anweisungen mehrmals ausführen so benutzt man oft Schleifen. Beispiele sind Zähler oder das Durchlaufen von Listen, Arrays,...

for-Schleife

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

Die for-Schleife wird deklariert wie im Code-Beispiel oben. Dabei ist 1 der Startpunkt und 5 der Endpunkt, i ist der Index. Obiger Code gibt folgendes aus:
1
2
3
4
5

while-Schleife

// while-Schleife
  var zahl = 24
  while (zahl > -10) {
    zwischenNullUndZehn(zahl)
    zahl -= 7
  }

Die while-Schleife schreibt sich wie das if-Statement. Solange die Bedingung in den Klammern erfüllt ist, wird die anschließende Zeile bzw. der anschließende Block ausgeführt.

do-while-Schleife

var hoehleInOrdnung = false
  var beuteVorHoehle = false
  println("Beiße Raupe")
  do {
    println("Ziehe Beute vor Höhle")
    beuteVorHoehle = true
    println("Prüfe ob in Höhle alles in Ordnung ist")
    hoehleInOrdnung = true
    //println("Entomologe schiebt Beute ein paar Zentimeter weg")
    //beuteVorHoehle = false
  } while (beuteVorHoehle == false || hoehleInOrdnung == false)
  println("Eier legen")

Die do-while-Schleife ist ähnlich der while-Schleife. Die Unterschiede sind, dass die Schleife mit do anfängt und while mit der Bedingung am Ende steht, und die Anweisungen werden garantiert einmal ausgeführt und nur wiederholt so lange die Bedingung erfüllt ist.
Im Code-Beispiel oben hätten wir übrigens eine Endlosschleife, wenn die zwei Zeilen nicht auskommentiert wären. Kommentare benutzt man, wenn man in klarer Sprache beschreiben will, was der Code macht, oder wenn man nicht will, dass bestimmter Code nicht ausgeführt wird, man ihn aber noch nicht löschen möchte. Zu Kommentaren werden wir dann auch näher eingehen.