Java-Variablen: De­kla­rie­ren, in­itia­li­sie­ren & Da­ten­ty­pen im Überblick

Java Variables fungieren als Container, die spe­zi­fi­sche Java-Da­ten­ty­pen aufnehmen. Sie lassen sich in lokale Variablen, In­stanz­va­ria­blen und statische Variablen gliedern. Auch wenn die Größe einer Variablen in Java fix definiert ist, kannst du ihren Inhalt jederzeit flexibel anpassen.

Was sind Java Variables ei­gent­lich?

In jeder Pro­gram­mier­spra­che sind Variablen die Basis, um innerhalb des Codes mit Daten zu arbeiten. Ver­ein­facht gesagt sind sie Container für Daten eines be­stimm­ten Typs. In Java speichern Variablen ei­ner­seits primitive Java-Da­ten­ty­pen wie Ganz­zah­len, De­zi­mal­zah­len, Wahr­heits­wer­te (true/false) oder einzelne Zeichen. An­de­rer­seits lassen sich auch komplexe Da­ten­ty­pen wie Java Strings hin­ter­le­gen. Java Variables besitzen eine feste Größe, die un­ver­än­der­lich bleibt – der ent­hal­te­ne Wert hingegen kann beliebig oft über­schrie­ben werden. Wir sehen uns die ver­schie­de­nen Typen nun im Detail an.

Java var de­kla­rie­ren und in­itia­li­sie­ren

Bevor du mit Daten arbeitest, musst du Java-Variablen de­kla­rie­ren und danach in­itia­li­sie­ren. Dieser Ablauf bleibt für alle Typen identisch. Für die De­kla­ra­ti­on legst du zwei Parameter fest: zuerst den ge­wünsch­ten Datentyp und an­schlie­ßend den Namen deiner Java-Variablen.

Bei der dar­auf­fol­gen­den In­itia­li­sie­rung spielen drei Faktoren zusammen: Datentyp, Name und der konkrete Wert. Damit weist du der noch leeren Variablen ihren ersten Inhalt zu. Die Syntax sieht so aus:

Datentyp Name = Wert;

Die drei Va­ria­blen­ty­pen in Java

Java Variables werden in drei Haupt­ka­te­go­rien un­ter­teilt: lokale Variablen, In­stanz­va­ria­blen und statische Variablen.

Lokale Variablen

Wenn eine Java var direkt im Hauptteil definiert wird, ist sie eine lokale Variable. Ihr Ein­satz­ge­biet be­schränkt sich auf die jeweilige Methode, den Con­s­truc­tor oder den spe­zi­fi­schen Block. Hier ein prak­ti­sches Beispiel:

public class Main {
	public static void main(String[] args) {
		int var = 5;
		System.out.println("Die lokale Variable ist: " + var);
	}
}

Die ent­spre­chen­de Ausgabe dazu:

Die lokale Variable ist: 5

In­stanz­va­ria­blen

Wird eine Java var innerhalb der Klasse, aber außerhalb von Methoden de­kla­riert, nennt man sie In­stanz­va­ria­ble. Diese wird aktiv, sobald du ein Objekt mittels „new“ erzeugst. Im Un­ter­schied zu lokalen Variablen besitzen In­stanz­va­ria­blen Stan­dard­wer­te (0 oder 0.0 bei Zahlen, false bei Booleans, null bei Objekten). Im folgenden Beispiel berechnen wir die Beiträge für ein ge­mein­sa­mes Ge­burts­tags­ge­schenk:

public class Geschenk {
	public String name;
	private double anteil;
	public Geschenk (String person) {
		name = person;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getAnteil() {
		return anteil;
	}
	public void setAnteil(double teilnehmerAnteil) {	
		anteil = teilnehmerAnteil;
	}
	public static void main(String[] args) {
		Geschenk teilnehmer = new Geschenk ("Peter");
		teilnehmer.setAnteil(10);
		System.out.println("Name: " + teilnehmer.getName());
		System.out.println("Anteil = " + teilnehmer.getAnteil());
		Geschenk teilnehmer2 = new Geschenk ("Sabine");
		teilnehmer2.setAnteil(15);
		System.out.println("Name: " + teilnehmer2.getName());
		System.out.println("Anteil = " + teilnehmer2.getAnteil());
	}
}

Die Ausgabe für diesen Code lautet:

Name: Peter
Anteil = 10.0
Name: Sabine
Anteil = 15.0

Statische Variablen

Statische Variablen werden außerhalb von Methoden oder Blöcken de­kla­riert und gehören direkt zur Klasse, nicht zu einer einzelnen Instanz. Das bedeutet, alle Instanzen greifen auf dieselbe Variable zu. Die Spei­cher­re­ser­vie­rung erfolgt bereits beim Laden der Klasse. Ein Beispiel dazu:

public class Geschenk {
	public static String teilnehmer = "Peter";
	public static void main(String[] args) {
		System.out.println("Teilnehmer: " + Geschenk.teilnehmer);
	}
}

Das Ergebnis der Ausgabe:

Teilnehmer: Peter

Wie erstellt man ver­schie­de­ne Variablen?

Die Er­stel­lung von Java Variables folgt immer demselben Schema. Wir zeigen dir die wich­tigs­ten Typen und erklären kurz, worauf es ankommt.

boolean

Ein Boolean speichert aus­schließ­lich die Wahr­heits­wer­te true (wahr) oder false (falsch). So sieht die De­kla­ra­ti­on aus:

public class Main {
	public static void main(String[] args) {
		boolean pommesSindLecker = true;
		System.out.println(pommesSindLecker);
	}
}

Die Ausgabe dazu:

true

int

int ist der Standard-Datentyp für ganze Zahlen. Solche Java-Variablen de­kla­rierst du fol­gen­der­ma­ßen:

public class Main {
	public static void main(String[] args) {
		int x = 10;
		System.out.println(x);
	}
}

Das ist das Ergebnis:

10

float

Für Zahlen mit Nach­kom­ma­stel­len nutzt du float. Die Variable wird wie folgt erstellt:

public class Main {
	public static void main(String[] args) {
		float x = -17.03f;
		System.out.println(x);
	}
}

Die passende Ausgabe:

-17.03

char

char speichert ein einzelnes Schrift­zei­chen, das in einfache An­füh­rungs­zei­chen gesetzt wird. Hier ein Beispiel:

public class Main {
	public static void main(String[] args) {
		char x = 'S';
		System.out.println(x);
	}
}

So sieht die Ausgabe aus:

S

String

Neben den einfachen Typen können Java Variables auch ganze Text­ket­ten (Strings) aufnehmen. Diese Texte stehen immer in doppelten An­füh­rungs­zei­chen. Ein Beispiel für die Praxis:

public class Main {
	public static void main(String[] args) {
		String beispiel = "Dies ist ein Beispiel für einen String in Java.";
		System.out.println(beispiel);
	}
}

Die Ausgabe dazu:

Dies ist ein Beispiel für einen String in Java.