Scala for Backend Engineering & Functional Programming · Lektion

val, var und Typen

Bindungen und Inferenz

val, var und Typen ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Bindings in Scala

In Scala geben Sie Werten mithilfe von Bindings Namen. Die beiden Schlüsselwörter sind val und var.

Ein val ist unveränderlich (es kann nicht neu zugewiesen werden), während ein var veränderlich ist (es kann neu zugewiesen werden).

Ein <code>val</code> deklarieren

Ein val bindet einen Namen einmalig an einen Wert. Der Versuch, ihm einen neuen Wert zuzuweisen, führt zu einem Kompilierungsfehler.

Verwenden Sie standardmäßig bevorzugt val. Unveränderlichkeit macht Code leichter nachvollziehbar.

object Main {
  def main(args: Array[String]): Unit = {
    val name = "Ada"
    println(name)
  }
}

Ein <code>var</code> deklarieren

Ein var kann mit = neu zugewiesen werden. Verwenden Sie es nur, wenn Sie tatsächlich einen veränderlichen Zustand benötigen.

Beachten Sie, dass der neue Wert weiterhin zum ursprünglichen Typ passen muss.

object Main {
  def main(args: Array[String]): Unit = {
    var count = 0
    count = count + 1
    count = count + 1
    println(count)
  }
}

Typinferenz

Scala ermittelt den Typ normalerweise für Sie. Wenn Sie val x = 42 schreiben, wird x automatisch zu einem Int.

Dies nennt man Typinferenz: Sie erhalten statische Typisierung, ohne den Typ immer angeben zu müssen.

object Main {
  def main(args: Array[String]): Unit = {
    val x = 42
    val pi = 3.14
    val flag = true
    println(x)
    println(pi)
    println(flag)
  }
}

Explizite Typannotationen

Sie können den Typ auch explizit nach einem Doppelpunkt angeben: val x: Int = 42.

Das ist für die Dokumentation nützlich oder wenn Sie einen allgemeineren Typ als den abgeleiteten wählen möchten.

object Main {
  def main(args: Array[String]): Unit = {
    val age: Int = 30
    val price: Double = 9.99
    val label: String = "Sale"
    println(label + ": " + price)
  }
}

Gängige numerische Typen

Scala verfügt über mehrere numerische Typen:

Int für ganze Zahlen
Long für große ganze Zahlen
Double für Dezimalzahlen
Float für Dezimalzahlen mit geringerer Genauigkeit

Ein ganzzahliges Literal wird standardmäßig als Int interpretiert; ein Dezimalliteral standardmäßig als Double.

object Main {
  def main(args: Array[String]): Unit = {
    val whole: Int = 7
    val big: Long = 9000000000L
    val dec: Double = 2.5
    println(whole + dec)
  }
}

Boolean und Char

Boolean enthält true oder false. Char enthält ein einzelnes Zeichen, das in einfachen Anführungszeichen geschrieben wird.

Dies sind vollwertige Typen, die Sie in vals und vars speichern können.

object Main {
  def main(args: Array[String]): Unit = {
    val isReady: Boolean = true
    val grade: Char = 'A'
    println(isReady)
    println(grade)
  }
}

Der Typ String

String enthält Text in doppelten Anführungszeichen. Strings sind in Scala unveränderlich.

Sie können sie mit + verketten und viele nützliche Methoden darauf aufrufen.

object Main {
  def main(args: Array[String]): Unit = {
    val first = "Grace"
    val last = "Hopper"
    val full = first + " " + last
    println(full.toUpperCase)
  }
}

Warum <code>val</code> statt <code>var</code>?

Unveränderliche Werte verhindern eine ganze Klasse von Fehlern: Nichts anderes kann sie unbemerkt verändern.

Leichter nachvollziehbar
Sicherer in nebenläufigem Code
Fördert einen funktionalen Stil

Verwenden Sie var nur, wenn Veränderlichkeit wirklich erforderlich ist.

Typsicherheit in der Praxis

Da Scala statisch typisiert ist, erkennt der Compiler Typkonflikte, bevor das Programm ausgeführt wird.

Die Zuweisung von Text an einen Int würde bereits beim Kompilieren fehlschlagen. Hier sehen Sie gültigen, typkorrekten Code.

object Main {
  def main(args: Array[String]): Unit = {
    val quantity: Int = 3
    val unitPrice: Double = 4.50
    val total: Double = quantity * unitPrice
    println(total)
  }
}

Alles zusammenführen

Kombinieren Sie unveränderliche und veränderliche Bindings mit Typinferenz und Typannotationen in einem kleinen Programm.

Beachten Sie, wie der Compiler jeden Typ für Sie verfolgt.

object Main {
  def main(args: Array[String]): Unit = {
    val base = 100
    var running = base
    val step: Int = 25
    running = running + step
    println(running)
  }
}

Kurzer Test

Überprüfen Sie Ihr Verständnis von Bindings und Typen.

Zusammenfassung

Sie haben gelernt, wie Scala Werte benennt:

val ist ein unveränderliches Binding; var ist veränderlich
Die Typinferenz leitet den Typ aus dem Wert ab
Sie können explizite Typannotationen wie val x: Int hinzufügen
Zu den grundlegenden Typen gehören Int, Long, Double, Boolean, Char und String
Bevorzugen Sie val für sichereren und klareren Code

Häufig gestellte Fragen

Ist die Lektion „val, var und Typen“ kostenlos?

Ja — der vollständige Text von „val, var und Typen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „val, var und Typen“?

Bindungen und Inferenz Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „val, var und Typen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming