Java Variablen & Datentypen: Guide für IT-Einsteiger

Stell dir vor, du sitzt in deiner ersten Programmierübung an der Berufsschule oder im Uni-Seminar. Die Aufgabe: Ein kleines Programm soll das Gehalt eines Mitarbeiters berechnen. Du öffnest Eclipse oder IntelliJ, starrst auf den leeren Editor und fragst dich: Wo fange ich an? Genau hier kommen Java Variablen Datentypen ins Spiel - die absoluten Grundbausteine jedes Java-Programms.

Egal, ob du eine Umschulung zum Fachinformatiker machst, Informatik im ersten Semester studierst oder als Quereinsteiger deine ersten Zeilen Code schreibst: Ohne Variablen und Datentypen funktioniert in Java gar nichts. In diesem Guide erkläre ich dir beide Konzepte Schritt für Schritt.

Was ist eine Variable in Java?

Eine Variable ist ein benannter Speicherplatz im Arbeitsspeicher deines Programms. Stell dir eine Variable wie eine beschriftete Schublade vor: Auf der Vorderseite steht ein Name (z.B. "gehalt"), und drin liegt ein Wert (z.B. 3500). Du kannst den Wert jederzeit austauschen - deshalb der Name "Variable".

Bevor du eine Variable nutzen kannst, musst du sie deklarieren. Das bedeutet: Du sagst Java, wie die Variable heißt und welchen Typ von Daten sie aufnehmen soll.

// Deklaration einer Variable
int alter;
// Deklaration mit direkter Wertzuweisung (Initialisierung)
int alter = 25;

Warum musst du den Typ angeben? Weil Java eine statisch typisierte Sprache ist. Der Compiler (das Programm, das deinen Code in ausführbaren Maschinencode übersetzt) muss schon beim Kompilieren wissen, wie viel Speicherplatz er reservieren muss. Das unterscheidet Java von Sprachen wie Python oder JavaScript, wo der Typ erst zur Laufzeit bestimmt wird.

Merke: Eine Variable in Java besteht immer aus drei Teilen: Datentyp, Name und Wert.

Welche Datentypen gibt es für Java Variablen?

Datentypen definieren, welche Art von Daten eine Variable speichern darf und welche Operationen du mit diesen Daten durchführen kannst. Es gibt in Java zwei Hauptkategorien: primitive Datentypen und Referenzdatentypen.

Primitive Datentypen - Die acht Grundbausteine

Primitive Datentypen sind die einfachsten Datentypen in Java. Sie speichern direkt den Wert und kommen ohne zusätzlichen Overhead aus. Stell dir vor, du kaufst im Baumarkt standardisierte Boxen in verschiedenen Größen - für Schrauben, für Nägel, für Werkzeug. Genauso bietet Java acht Standardboxen für verschiedene Datenarten:

Für den Alltag brauchst du davon meistens nur vier: `int` für ganze Zahlen, `double` für Kommazahlen, `boolean` für ja/nein-Entscheidungen und `String` (ein Referenztyp) für Text.

Referenzdatentypen - Objekte und Strings

Im Gegensatz zu primitiven Datentypen speichern Referenzdatentypen nicht den Wert direkt, sondern eine Referenz (einen Verweis) auf ein Objekt im Speicher. Der wichtigste Vertreter für dich als Einsteiger: String.

// String ist ein Referenzdatentyp
String name = "Max Mustermann";
String nachricht = "Hallo " + name + "!";

Ein `String` kann beliebig lang sein und bietet viele nützliche Methoden wie `.length()` oder `.toUpperCase()`. Die offizielle Dokumentation aller String-Methoden findest du in den Oracle Java Docs.

Welche Datentypen solltest du wann nutzen?

Die Entscheidung für den richtigen Datentyp ist wichtig für die Speichereffizienz und die Genauigkeit deiner Berechnungen.

Faustregel: Wähle den kleinsten Datentyp, der deine Werte sicher aufnehmen kann. Warum? Weil Speicherplatz ressourcenschonend genutzt werden sollte, besonders bei großen Anwendungen.

Hier ist eine schnelle Entscheidungshilfe:

• Ganze Zahlen? Nimm `int`. Der reicht für 99 % aller Fälle (bis ca. 2 Milliarden).

• Kommazahlen? Nimm `double`. Der ist genauer als `float`.

• Ja oder Nein? `boolean` - gibt keine Alternative.

• Text? `String` - der Standard in Java.

• Einzelnes Zeichen? `char`.

Ausnahme: Wenn du mit extrem großen Zahlen arbeitest (z.B. Bevölkerungszahlen der Erde), nimm `long`. Bei finanziellen Berechnungen solltest du übrigens `double` vermeiden und stattdessen `BigDecimal` nutzen, da Fließkommazahlen ungenau sein können.

Wie deklarierst und initialisierst du Variablen?

Hier ist ein vollständiges Beispiel, wie du Java Variablen Datentypen in einem echten Programm nutzt. Stell dir vor, du sollst für ein Zeiterfassungssystem die Arbeitsstunden eines Mitarbeiters berechnen:

public class Zeiterfassung {
 public static void main(String[] args) {
 // Deklaration und Initialisierung
 String mitarbeiterName = "Anna Schmidt";
 int stundenProTag = 8;
 double stundenlohn = 22.50;
 boolean istVollzeit = true;
 
 // Berechnung des Wochenlohns (5 Tage)
 double wochenlohn = stundenProTag * stundenlohn * 5;
 
 // Ausgabe
 System.out.println("Mitarbeiter: " + mitarbeiterName);
 System.out.println("Vollzeit: " + istVollzeit);
 System.out.println("Wochenlohn: " + wochenlohn + " Euro");
 }
}

Was passiert hier genau?

1. Du deklarierst vier Variablen unterschiedlichen Typs und weist ihnen Werte zu.

2. Du berechnest den Wochenlohn mit einer mathematischen Formel.

3. Du gibst die Ergebnisse formatiert auf der Konsole aus.

Was sind Konstanten in Java?

Manchmal möchtest du, dass ein Wert nach der Initialisierung nicht mehr verändert werden kann. Dafür nutzt du das Schlüsselwort `final`. Solche Variablen nennt man Konstanten.

final double MEHRWERTSTEUER = 0.19;
final String UNTERNEHMENSNAME = "TechCorp GmbH";

// Das wuerde einen Compiler-Fehler verursachen:
// MEHRWERTSTEUER = 0.07;

Konstanten schreibst du konventionell in GROSSBUCHSTABEN mit Unterstrichen. Das ist zwar technisch keine Pflicht, aber ein etablierter Standard in der Java-Welt. Der Compiler erzwingt diese Namensgebung zwar nicht, aber deine Kollegen (und du selbst in sechs Monaten) werden es dir danken.

Wie funktioniert das Casting (Typumwandlung)?

Manchmal musst du einen Datentyp in einen anderen umwandeln. Java unterscheidet zwischen impliziter (automatischer) und expliziter (manueller) Typumwandlung.

Implizite Typumwandlung funktioniert automatisch, wenn der Zieltyp größer ist (z.B. von `int` zu `double`):

int ganzeZahl = 42;
double kommazahl = ganzeZahl; // automatisch: 42.0

Explizites Casting brauchst du, wenn du von einem größeren in einen kleineren Typ umwandelst (z.B. von `double` zu `int`). Hier kannst du Daten verlieren, deshalb musst du Java zwingen:

double pi = 3.14159;
int abgeschnitten = (int) pi; // manueller Cast: 3

Achtung: Beim Casten von `double` zu `int` schneidet Java die Nachkommastellen einfach ab - es wird nicht gerundet. Das ist ein häufiger Stolperstein in Prüfungen.

Welche Regeln gelten für Variablennamen?

Nicht jeder Name ist in Java erlaubt. Damit dein Code lesbar bleibt und der Compiler nicht streikt, solltest du folgende Konventionen beachten:

1. Keine Schlüsselwörter: Worte wie `class`, `int` oder `public` sind verboten.

2. Keine Leerzeichen oder Sonderzeichen: Nur Buchstaben, Ziffern, das Dollarzeichen ($) und der Unterstrich (_) sind erlaubt.

3. Nicht mit einer Ziffer beginnen: `var1` ist okay, `1var` ist falsch.

4. CamelCase: Variablennamen beginnen klein, jedes neue Wort groß. Beispiele: `meinAlter`, `stundenlohnBrutto`, `istVollzeit`.

Gute Namen sind essenziell. `int a;` mag kurz sein, aber `int anzahlStunden;` erklärt sofort, was in der Variable gespeichert ist.

Typische Anfängerfehler

Selbst Profis machen Fehler, aber diese drei fallen Einsteigern immer wieder auf die Füße:

Fehler 1: Vergessenes Semikolon

// FALSCH
String name = "Max"

// RICHTIG
String name = "Max";

Jede Anweisung in Java muss mit einem Semikolon enden.

Fehler 2: Falscher Datentyp bei Kommazahlen

// FALSCH - Java interpretiert 3.14 als double
float pi = 3.14; // Compiler-Fehler!

// RICHTIG - f-Suffix fuer float
float pi = 3.14f;

// ODER: direkt double nutzen
double pi = 3.14;

Java behandelt Kommazahlen standardmäßig als `double`. Wenn du `float` nutzen willst, musst du ein `f` anhängen.

Fehler 3: Variable nicht initialisiert

// FALSCH
int alter;
System.out.println(alter); // Compiler-Fehler!

// RICHTIG
int alter = 0;
System.out.println(alter);

Java verlangt, dass lokale Variablen (innerhalb von Methoden) einen Wert haben, bevor du sie liest. Es gibt keinen "Standardwert" wie bei globalen Variablen.

Übungstipp: Dein erstes Mini-Projekt

Erstelle eine Klasse `PersonalDaten`, die folgende Informationen als Variablen speichert und ausgibt:

• Name (String)

• Alter (int)

• Gehalt (double)

• Ist angestellt? (boolean)

Spiel dann mit den Werten: Berechne das Jahresgehalt, gib alle Daten formatiert aus und versuche, die Konstante `STEUERSATZ` hinzuzufügen. So verankerst du das Wissen direkt in deinen Händen - nicht nur im Kopf.

Falls du dabei auf Probleme stößt, hilft dir unser Beitrag zum Thema Java-Frust im Studium überwinden weiter. Für mehr Details zu den Typen empfiehlt sich auch ein Blick auf W3Schools Java Variables.

FAQ: Häufige Fragen zu Java Variablen und Datentypen

Was ist der Unterschied zwischen `int` und `Integer`?

`int` ist ein primitiver Datentyp und speichert direkt den Wert. `Integer` ist eine Wrapper-Klasse (ein Referenztyp), die den primitiven Wert in ein Objekt verpackt. Du brauchst `Integer` hauptsächlich bei Generics oder Collections wie `ArrayList<Integer>`.

Kann ich in Java den Datentyp einer Variable nachträglich ändern?

Nein. Java ist statisch typisiert. Einmal `int`, immer `int`. Du kannst den Wert ändern, aber nicht den Typ. Wenn du einen anderen Typ brauchst, musst du eine neue Variable deklarieren und den Wert gegebenenfalls casten.

Warum sollte ich `double` statt `float` verwenden?

`double` bietet ca. 15 Nachkommastellen Genauigkeit, `float` nur ca. 7. In den meisten Fällen ist `double` die sicherere und Standard-Wahl in Java.

Was bedeutet "Initialisierung"?

Initialisierung bedeutet, dass du einer Variable bei ihrer Erstellung direkt ihren ersten Wert gibst (z.B. `int x = 10;`). Wenn du nur `int x;` schreibst, ist sie deklariert, aber noch nicht initialisiert und hat (lokal) keinen Wert.

Was passiert, wenn `int` überläuft?

Wenn du den maximalen Wert von `int` (ca. 2,1 Mrd.) überschreitest, beginnt das "Zählen" wieder beim negativen Minimalwert. Das nennt man Integer Overflow. Für sehr große Zahlen solltest du `long` nutzen.

Fazit

Java Variablen Datentypen sind das Fundament jedes Java-Programms. Du weißt jetzt, dass Variablen benannte Speicherplätze sind und Datentypen festlegen, welche Art von Daten dort abgelegt werden. Die acht primitiven Typen decken Zahlen, Zeichen und Wahrheitswerte ab, während Referenztypen wie `String` komplexe Datenstrukturen ermöglichen.

Für den Start reicht es, sich auf `int`, `double`, `boolean` und `String` zu konzentrieren. Die restlichen Typen kommen automatisch ins Spiel, wenn du komplexere Programme schreibst.

Wenn du beim Üben merkst, dass du individuelle Hilfe brauchst - ob für die IHK-Prüfungsvorbereitung, die Uni-Klausur oder den Einstieg in dein erstes Projekt - schau dir an, was study-it.education bietet. Dort bekommst du gezielte Online-Nachhilfe von erfahrenen Dozenten, die genau wissen, welche Themen Azubis, Studenten und Berufseinsteiger am meisten fordern.