Variablen in Scala

Schau dir den neu gestarteten Scala-Kurs von DataCamp an: Introduction to Scala.

Scala wird von Data Scientists häufig eingesetzt, wenn es um große Datenmengen mit Apache Spark im Bereich Big Data geht. Es ist eine objektorientierte und funktionale Programmiersprache mit vielen wichtigen Eigenschaften:

1. Scala ist statisch typisiert: Der Datentyp einer Variable wird festgelegt, bevor sie verwendet wird. Die Typprüfung erfolgt zur Compile-Zeit, nicht zur Laufzeit.
2. Scala ist außerdem "stark typisiert": Variablen werden vor einer Operation auf ihren Typ geprüft.
3. Scala unterstützt Typinferenz: Der Compiler leitet den Typ aus Ausdrücken oder Literalen ab, sodass die explizite Typangabe optional ist.

In diesem Tutorial behandelst du folgende Themen:

• Variablen
• Regeln zur Definition von Variablen in Scala
• Veränderliche Variablen
• Unveränderliche Variablen
• Mehrfachdeklarationen und -zuweisungen
• Geltungsbereich von Variablen in Scala

Variablen

Variablen sind benannte Speicherbereiche. Der Compiler reserviert je nach Datentyp der entsprechenden Variable einen Speicherplatz. In Scala werden Variablen mit folgender Syntax deklariert:

val or val variable_name: variable_datatype = value;

In der obigen Syntax kann eine Variable auf zwei Arten definiert werden, mit dem Schlüsselwort 'var' oder 'val'. Sie besteht aus dem 'variable_name' als neuem Variablennamen, gefolgt von einem Doppelpunkt. Der Datentyp der Variablen ist 'variable_datatype' und kann jeder gültige Datentyp sein. Danach wird der 'value' dem 'variable_name' zugewiesen.

Beispiel:

val varValue: Byte = 8;

'val' ist das Schlüsselwort zum Definieren einer Variablen, und 'varValue' ist der Variablenname. Der Datentyp ist 'Byte' und der Wert ist 8. 'Byte' ist ein vorzeichenbehafteter 8-Bit-Wert im Bereich von 2⁻⁷ bis 2⁷−1.

Der 'variable_datatype' kann jeder in Scala vorhandene Datentyp sein, z. B.:

1. Int: Ein vorzeichenbehafteter 32-Bit-Wert mit dem Bereich von 2⁻³¹ bis 2³¹−1.
2. Byte: Ein vorzeichenbehafteter 8-Bit-Wert im Bereich von 2⁻⁷ bis 2⁷−1.
3. Short: Ein vorzeichenbehafteter 16-Bit-Wert im Bereich von 2⁻¹⁵ bis 2¹⁵−1.
4. Float: Kann 32 Bit oder 64 Bit umfassen.

Andere Datentypen wie Long, Char, Boolean, Char, String, Boolean, Null haben jeweils eigene Wertebereiche. Eine ausführliche Erklärung findest du im Tutorial Beginner’s Guide to Scala. Außerdem beginnt der 'variable_datatype' mit einem Großbuchstaben, z. B. 'I' in Int, was zeigt, dass alle oben genannten Datentypen in Scala Objekte sind.

Regeln zur Definition von Variablen in Scala

Die Regeln und Konventionen zur Definition von Variablen in Scala sind:

1. Variablennamen verwenden lowerCamelCase. Beispiel: Beim Variablennamen 'nameOfGirl' ist das erste 'n' klein. Danach werden die Wortanfänge wie 'O' und 'G' großgeschrieben.
2. Variablennamen dürfen keine reservierten Wörter oder Schlüsselwörter von Scala enthalten.
3. Variablennamen dürfen das Dollarzeichen ('$') und den Unterstrich ('_') enthalten. Andere Sonderzeichen wie '#', '&' etc. sind nicht erlaubt. Die Verwendung des Unterstrichs wird zudem nicht empfohlen.
4. Leerzeichen (Tabs, Space) sind in Variablennamen nicht erlaubt.
5. Ein Variablenname muss mit einem Buchstaben beginnen und darf nicht mit einer Zahl oder anderen Zeichen starten.

Veränderliche Variablen

Veränderliche Variablen erlauben es, ihren Wert auch nach der Deklaration zu ändern.

Die Syntax für eine veränderliche Variable lautet:

var variable_name : variable_datatype = value;

Alternativ kann die Syntax auch so aussehen:

var variable_name = value;

Beispiel für eine veränderliche Variable:

var nameOfThing: String = "Car";

Im obigen Beispiel steht var als Schlüsselwort für veränderliche Variablen. Der Variablenname ist 'nameOfThing'. Darauf folgt ein Doppelpunkt mit dem Datentyp 'String'. Der im Speicher abgelegte Wert ist 'Car'.

Dasselbe Beispiel mit alternativer Syntax:

var nameOfThing = "Car";

Du kannst den Datentyp weglassen, wie oben gezeigt. Der Scala-Compiler erkennt automatisch den Typ 'String' – das nennt man Typinferenz.

Den Wert der Variablen kannst du einfach ändern:

nameOfThing = "Bike";
print(nameOfThing)

Der Wert ändert sich von "Car" auf "Bike". Die Ausgabe ist "Bike", weil das Schlüsselwort 'var' das Ändern des Variablenwerts erlaubt (Quelle: Variables in Scala).

Unveränderliche Variablen

Unveränderliche Variablen können nach ihrer Erstellung nicht mehr geändert werden und werden mit dem Schlüsselwort 'val' deklariert.

Die Syntax für eine unveränderliche Variable lautet:

val variable_name : variable_data type = value;

Alternativ kann die Syntax auch so aussehen:

val variable_name = value;

Beispiel für eine unveränderliche Variable:

val numberOfThing: Int = 2;

Im obigen Beispiel steht val als Schlüsselwort für unveränderliche Variablen, der Variablenname ist 'numberOfThing'. Darauf folgt ein Doppelpunkt mit dem Datentyp 'Int', und im Speicher wird der Wert 2 abgelegt.

Dasselbe Beispiel mit alternativer Syntax:

val numberOfThing = 2;

Du kannst den Datentyp weglassen, wie oben gezeigt. Der Scala-Compiler erkennt automatisch den Typ 'Int'. Dieser Vorgang heißt Typinferenz (Quelle: Variables in Scala).

Du kannst den Wert der Variablen nicht ändern, wie hier gezeigt:

numberOfThing = 7;

Das führt zu einem Fehler wie "error: not found: value numberOfThing" und zeigt, dass eine erneute Zuweisung nicht möglich ist, wie unten dargestellt:

Mehrfachdeklarationen und -zuweisungen

In Scala kannst du mehrere Variablen in einer Zeile mit dem Schlüsselwort 'var' deklarieren und ihnen gleichzeitig Werte zuweisen. Die Variablennamen werden durch Kommata getrennt und mit "=" zugewiesen.

var (x, y, z) = (5, 4.5, "Sit")

Im obigen Beispiel erhalten die Variablen x, y und z die Werte 5, 4.5 und "Sit" in entsprechender Reihenfolge.

Mehrfachzuweisungen sind in Scala auch mit 'val' möglich, wenn mehrere Variablennamen durch Kommata getrennt und mit dem gleichen Wert belegt werden.

val a, b, c = 1;

Hier erhalten die Variablen a, b und c jeweils den Wert 1.

Geltungsbereich einer Variable

Der Geltungsbereich beschreibt die Sichtbarkeit und Lebensdauer von Variablen innerhalb bestimmter Codeblöcke. Variablen können lokal oder global definiert sein. Beispiel:

var globalVar = 10
def sub(){
var difference = 9-4;
}
print(difference)//Error
print(globalVar)//Valid

Im obigen Code ist 'difference' lokal im Geltungsbereich der Methode 'sub' deklariert. Die Subtraktion liefert dort ein gültiges Ergebnis, aber das Ausgeben außerhalb der Methode 'sub' führt zu einem Fehler. Dagegen hat 'globalVar' globalen Geltungsbereich und kann überall im Programm verwendet werden.

In Scala gibt es drei Geltungsbereichsarten für Variablen (Quelle: Scala- Variables):

1. Lokale Variablen
2. Felder
3. Methodenparameter

Lokale Variablen

Lokale Variablen sind veränderliche oder unveränderliche Variablen, die innerhalb einer Methode deklariert werden und nur dort zugänglich sind – nicht außerhalb.

Ein einfaches Beispiel für lokale Variablen:

class Perimeter  
{
    def triangle()  
    {
        var side1 = 10;
        var side2 = 20;
        var side3 = 30;

        var total = side1+side2+side3;
        print("Perimeter of the  triangle is: " + total);
    }
}

object Test  
{

    def main(args:Array[String])  
    {
        val p1 = new Perimeter()
        p1.triangle()
    }
}

defined class Perimeter
defined object Test

Die Ausgabe lautet:

The perimeter of the triangle is: 60

Das Programm enthält eine Klasse 'Perimeter' und ein Objekt 'Test' mit einer Methode 'triangle', die drei veränderliche Variablen side1, side2, side3 verwendet. Berechnung und Ausgabe erfolgen innerhalb der Methode und liefern das korrekte Ergebnis.

Felder

Variablen, die innerhalb einer Klasse definiert sind, heißen Feldvariablen und können veränderlich oder unveränderlich sein. Wird eine Variable in der Klasse, aber nicht innerhalb einer Methode deklariert, ist der Zugriffsmodifikator standardmäßig public und die Variable ist im gesamten Programm sichtbar. Eine private Variable kann dagegen innerhalb der definierten Klasse verwendet werden, ist aber außerhalb des Klassenkontexts (auch in Objekten) nicht zugänglich.

class FieldExample
{
  var value1 = 10;
  private var value2 = 30;
  def operation()
  {
    println("Value of value1:"+value1)
  }
  println("Value of value2: "+value2);
}

object Demo
{
  def Main(args:Array[String])
  {
    val obj = new FieldExample()
    obj.operation()
    print(obj.value1)//Valid
    print(obj.value2)


  }
}

defined class FieldExample
defined object Demo

Die Ausgabe lautet:

Value of value2: 30
Value of value1:10
10

Das Programm enthält die Klasse 'FieldExample', das Objekt 'Demo' und die Methode 'operation'. Die öffentliche Variable value1 kann per Punktnotation ausgelesen werden, der ausgegebene Wert ist 10. Die private Variable value2 ist 30; der Zugriff und die Ausgabe außerhalb der Klasse führen zu einem Fehler.

Methodenparameter

Methodenparameter sind Variablen, die beim Aufruf einer Methode Werte entgegennehmen. Die Parameter werden mit 'val' definiert und sind damit unveränderlich. Über Referenzen können sie außerhalb der Methode verwendet werden, soweit der Geltungsbereich dies erlaubt.

Ein einfaches Beispiel zu Methodenparametern:

class Triangle
{
    def calculate(height: Int, width: Int)
    {
        var result = 0.5*(height+width);
        println("Area of triangle is: " + result);
    }
}

object Area  
{
     def main(args:Array[String])
    {
        val a = new Triangle()
        a.calculate(4,5);
    }
}

defined class Triangle
defined object Area

Die Ausgabe lautet:

Area of triangle is: 4.5

Die Klasse 'Triangle' enthält die Methode 'calculate' mit zwei Methodenparametern height und width. Beim Aufruf über das Objekt a werden die Integer-Werte 4 und 5 übergeben.

Fazit

Glückwunsch, du hast das Ende dieses Tutorials erreicht!

Du hast Variablen in Scala kennengelernt: Regeln zur Definition, verschiedene Variablentypen, Mehrfachdeklarationen und -zuweisungen sowie den Geltungsbereich von Variablen.

Wenn du mehr über Scala lernen möchtest, besuche den Kurs Introduction to Scala von DataCamp.