03 Java – Variablen

Variablen sind benannte Speicherstellen und dienen dazu, Daten im Hauptspeicher zu allokieren. Durch die Benennung kann auf die Variablen zugegriffen werden und Datenwerte hineingeschrieben und später wieder ausgelesen oder verändert werden. Es wird zwischen 5 Variablenarten unterschieden.

Lokale Variablen existieren nur innerhalb von Methoden oder Anweisungsblöcken.
Parametervariablen existieren ebenfalls nur innerhalb von Methoden. Auch sie sind automatisch immer lokale Variablen, die in der Parameterliste deklariert werden und Werte beinhalten, die über einen Methodenaufruf an die Methoden übergeben wurden.
Objektvariablen (auch Instanzvariablen genannt) werden im Rahmen einer Klasse definiert und zusammen mit Objekten angelegt.
Klassenvariablen (auch statische Variablen genannt) werden ebenfalls innerhalb einer Klasse definiert, existieren jedoch unabhängig von Objekten.
Konstanten sind immer Klassenvariablen. Der Wert kann jedoch nicht überschrieben werden.

Variablendeklaration

Eine Variable besteht, abhängig vom primitiven oder Referenzdatentyp, aus verschiedenen Bestandteilen.

1. Datentyp

2. Bezeichner der Variablen

3. Zuweisungsoperator =

4. Literal

5. Semikolon ;

type identifier = literal;

      int meaningOfLife = 42;
      boolean isRunning = false;
      char at = '@';
    

Bestandteil	Beispiel
type	`int`, `char`, `boolean`
identifier	`meaningOfLife`, `isRunning`, `at`
literal	`42`, `false`, `@`

1. Datentyp

2. Bezeichner der Variablen

3. Zuweisungsoperator =

4. Schlüsselwort new

5. Datentyp

6. Runde Klammern ()

7. Semikolon ;

Type identifier = new Type();

      String name = "Kesares";
      Movie movie = new Movie();
      Dog dog = new Dog();
    

Bestandteil	Beispiel
type	`String`, `Movie`, `Dog`
identifier	`name`, `movie`, `dog`
object	`"Kesares"`, `Movie()`, `Dog()`

Deklaration vs. Initialisierung

Durch eine Deklaration wird eine Variable erstellt und Speicherplatz für sie reserviert. Dabei wird der Variablen noch kein Wert zugewiesen. Dies erfolgt erst durch eine Initialisierung.

Die Deklaration und Initialisierung einer Variablen kann entweder in einer oder in zwei separaten Zeilen erfolgen.

int x;       // declaration
x = 15;      // initialization

int y = 10;  // declaration & initialization
y = 42;      // assignment, value is overwritten

Auch mehrere Variablen in einer Zeile sind möglich.

int v1, v2, v3;                // declaration
int v4 = 10, v5 = 11, v6 = 12; // declaration & initialization

Typumwandlung

Als Typumwandlung (engl. type casting) wird die Umwandlung eines Datentyps in einen anderen bezeichnet. In Java wird zwischen 2 Arten unterschieden.

Implizite Typumwandlung
Explizite Typumwandlung

Implizite Typumwandlung

Die implizite Typumwandlung erfolgt automatisch bei der Zuweisung von Werten. Dabei wird ein Datentyp mit niedrigerer Präzision in einen Datentyp mit höherer Präzision umgewandelt, zum Beispiel vom Typ int zum Typ long.

int i = 42;
long l = i;

Explizite Typumwandlung

Die explizite Typumwandlung erfolgt mithilfe des cast-Operators, der eine gezielte Konvertierung im Quellcode ermöglicht. Dabei wird ein Datentyp mit höherer Präzision in einen Datentyp mit niedrigerer Präzision umgewandelt, zum Beispiel von short in byte oder von float in int. Der cast-Operator erfordert die explizite Angabe des Zieltyps, in den umgewandelt werden soll.

short s = 128;
byte b = (byte) s;

float f = 3.14;
int i = (int) f;

Wenn in einer Zeile, in der ein Cast durchgeführt wird, auch eine Berechnung stattfinden soll, muss die Berechnung in runden Klammern gesetzt werden. Dadurch wird sichergestellt, dass die Berechnung vor der Typumwandlung ausgeführt wird.

double a = 10.5;
short b = 20;

short ab = (short) (a + b);

Reservierter Typname – `var`

Seit Java 10 ist es möglich die explizite Typangabe durch ein var zu ersetzen. var dient im Rahmen der Type Inference als Platzhalter für einen Datentyp.

        int meaningOfLife = 42;
        boolean isRunning = false;
        char at = '@';
    

        var meaningOfLife = 42;
        var isRunning = false;
        var at = '@';
    

Sowohl die Deklaration als auch die Initialisierung müssen in derselben Zeile stehen. Der Compiler ermittelt den Typ der Variablen selbst. Zudem kann var nur für lokale Variablen eingesetzt werden.

Lebensdauer und Sichtbarkeit

Die Lebensdauer beschreibt die Zeitspanne von der „Geburt“ bis zum „Tod“ einer Variablen. Die Lebensdauer einer lokalen Variablen beginnt mit der Variablendeklaration. Wurde die Variable innerhalb einer Block-Anweisung deklariert, endet ihre Lebenszeit mit Verlassen des Blocks. Wurde die Variable in einer Methode deklariert, dann wird ihre Existenz mit Ende des Methodenaufrufs ausgelöscht. Solange eine Variable existiert ist sie auch für andere Programmteile sichtbar.

Folgendes Beispiel zur Veranschaulichung. Zu beachten sind die geschweiften Klammern {}:

{ // Start of 1st block
	int i = 10;
	i++;
	{ // Start of 2nd block
		int j = 10;
		i++;
		j++;
		{ // Start of 3rd block
			int k = 10;
			i++;
			j++;
			k++;
		} // End of 3rd block
		i++;
		j++;
		k++; // Out of scope
	} // End of 2nd block
	i++;
	j++; // Out of scope
	k++; // Out of scope
} // End of 1st block

Die Variable i ist in allen Anweisungsblöcken sichtbar. Die Variable j ist nur im 2. und 3. Block sichtbar. Die Variable k ist nur im 3. Block sichtbar.

Bei den letzten beiden Zuweisungen, kann nicht auf die Variable j und k zugegriffen werden, da sie nur innerhalb des 2. bzw. 3. Blocks existieren. Dasselbe gilt für den Variablenzugriff k im 2. Anweisungsblock.

Typisierung

Starke vs. schwache Typisierung

Stark typisiert bedeutet, dass eine Sprache sehr strikt bei der Durchsetzung von Datentypen vorgeht. Wird eine Variable angelegt, sorgt Java auch dafür, dass der Programmierer genau angeben muss, welchen Datentyp diese Variable haben soll. Zudem behält Java bzw. der Compiler ein Auge darauf, dass sich der Typ dieser Variablen nicht verändert. Einmal eine Variable erstellt, behält sie den Typ bis zum Ende der Lebensdauer.

Eine Ausnahme bildet hier die in Java 10 hinzugefügte Möglichkeit Variablen mit var anzugeben. Doch auch hier bleibt während der gesamten Lebensdauer der Typ gleich.

Schwach typisiert bedeutet, dass eine Sprache "nachsichtiger" ist, wenn es um Typisierung geht. Hier wird eine automatische Typenumwandlung durchgeführt, um möglichst einfach Resultate generieren zu können.

Statische vs. dynamische Typisierung

Statisch typisiert bedeutet, dass eine Sprache zur Kompilierungszeit sicherstellt, dass alle Typregeln stets befolgt werden.

Bei der dynamischen Typisierung findet diese Überprüfung nicht zur Kompilierungszeit, sondern später zur Laufzeit statt, wenn das Programm bereits läuft. Dies macht das Schreiben von Code einfacher, da der Entwickler sich nicht darum kümmern muss, welche Datentypen die Variablen haben. Allerdings erschwert dies auch das spätere Debugging, sollte es zu einem Runtime Error kommen, wenn zwei Datentypen inkompatibel sind.

Coding Conventions

Variablen sollten nach der CamelCase-Notation geschrieben werden.
Bei einer Schleifenvariable ist auch ein einziger Buchstabe ausreichend.
Variablen vom Typ boolean, sollten nach Möglichkeit mit is beginnen. Alternativ kann auch auf has zurückgegriffen werden.
Konstanten sollten nach der SCREAMING_SNAKE_CASE-Notation geschrieben werden.

Last modified: 24 October 2024