Java-Syntax und Datentypen verstehen: Variablen, Strings und Typumwandlungen

Das Grundgerüst von Java-Code

Java-Quellcode besteht aus Deklarationen, Ausdrücken, Anweisungen und Blöcken. Anweisungen enden häufig mit einem Semikolon. Geschweifte Klammern fassen mehrere Anweisungen zu einem Block zusammen und bestimmen zugleich oft einen Gültigkeitsbereich.

package de.tinytool.grundlagen;

public class TemperaturCheck {
    public static void main(String[] args) {
        double temperatur = 21.5;

        if (temperatur >= 20.0) {
            System.out.println("Angenehm warm");
        }
    }
}

Im Beispiel ist double temperatur = 21.5 eine Deklarationsanweisung. temperatur >= 20.0 ist ein Ausdruck, der einen booleschen Wert liefert. Der Block hinter if wird nur ausgeführt, wenn dieser Wert true ist.

Kommentare gezielt einsetzen

// Kommentar bis zum Zeilenende

/* Kommentar über
   mehrere Zeilen */

/** Dokumentation für Javadoc. */

Ein Kommentar sollte vor allem Absicht, Randbedingungen oder eine ungewöhnliche Entscheidung erklären. Was der Code bereits klar ausdrückt, muss nicht noch einmal in Worten danebenstehen.

Variablen, Initialisierung und Gültigkeit

Eine Variable verbindet einen Namen mit einem typisierten Speicherplatz. Bei der Deklaration legst du den Typ fest; bei der Initialisierung erhält die Variable ihren ersten Wert.

int anzahl;          // deklariert, lokal noch nicht lesbar
anzahl = 3;          // erster Wert

double preis = 19.90; // Deklaration und Initialisierung
final int MAX_VERSUCHE = 3;

Eine lokale Variable muss auf jedem möglichen Programmpfad initialisiert sein, bevor sie gelesen wird. Der Compiler verhindert so die Verwendung eines unbestimmten Werts. Felder einer Klasse erhalten zwar typspezifische Standardwerte, etwa 0, false oder null; eine fachlich sinnvolle Initialisierung macht den Zustand dennoch deutlicher.

Der Gültigkeitsbereich

int gesamt = 0;

for (int i = 0; i < 3; i++) {
    int einzelwert = i * 10;
    gesamt += einzelwert;
}

System.out.println(gesamt);
// i und einzelwert sind hier nicht mehr sichtbar.

Je kleiner der Gültigkeitsbereich, desto leichter lässt sich nachvollziehen, wo ein Wert entsteht und verändert wird. Deklariere lokale Variablen daher möglichst nahe an ihrer ersten Verwendung.

final schützt die Zuweisung

Eine mit final deklarierte Variable kann nach ihrer Initialisierung nicht auf einen anderen Wert beziehungsweise eine andere Referenz gesetzt werden. Bei einem veränderlichen Objekt bedeutet das jedoch nicht, dass auch sein innerer Zustand unveränderlich ist.

final List namen = new ArrayList<>();
namen.add("Ada");      // erlaubt: Das Objekt wird verändert.
// namen = List.of();  // nicht erlaubt: neue Referenz

Die acht primitiven Datentypen

Primitive Typen repräsentieren elementare Werte. Sie sind keine Objekte und können nicht null sein.

boolean aktiv = true;
int besucher = 1_250_000;
long dateigroesse = 9_000_000_000L;
double temperatur = 21.5;
char initiale = 'G';

Geldbeträge sind kein double-Standardfall

Binäre Gleitkommatypen können viele Dezimalbrüche nicht exakt darstellen. Für Geldwerte mit festgelegten Dezimalregeln eignet sich häufig BigDecimal zusammen mit einer ausdrücklich gewählten Rundungsstrategie.

Referenztypen und null

Klassen, Interfaces, Records, Enums und Arrays definieren Referenztypen. Eine Variable dieses Typs enthält nicht das Objekt selbst, sondern eine Referenz darauf. Mehrere Variablen können deshalb dasselbe Objekt bezeichnen.

String ersterName = "Ada";
String zweiterName = ersterName;
int[] punkte = {12, 18, 24};
LocalDate heute = LocalDate.now();

Der besondere Wert null bedeutet, dass keine Objektreferenz vorhanden ist. Ein Methodenaufruf über null führt zu einer NullPointerException. Am besten modellierst du Pflichtwerte so, dass sie bereits beim Erzeugen eines Objekts vorhanden sind, und lässt null nicht unkontrolliert durch das Programm wandern.

Strings und Textblöcke

String ist eine Klasse und damit ein Referenztyp. String-Objekte sind unveränderlich: Methoden wie toUpperCase() oder replace() erzeugen einen neuen String, statt den bestehenden zu verändern.

String vorname = "Ada";
String begruessung = "Hallo, " + vorname + "!";
String gross = begruessung.toUpperCase();

System.out.println(begruessung); // Hallo, Ada!
System.out.println(gross);       // HALLO, ADA!

Für viele Verkettungen in einer Schleife ist StringBuilder meist die passendere Wahl. Mehrzeilige Texte lassen sich mit Textblöcken lesbar notieren:

String json = """
        {
          "name": "Ada",
          "aktiv": true
        }
        """;

Lokale Typinferenz mit var

Mit var kann der Compiler den Typ einer lokalen Variablen aus dem Initialisierer ableiten. Java bleibt dabei statisch typisiert; der Typ verschwindet nicht, er wird nur nicht doppelt hingeschrieben.

var titel = "Java-Grundlagen";       // String
var anzahl = 3;                      // int
var namen = List.of("Ada", "Linus"); // List

var ist nur für lokale Variablen mit Initialisierer vorgesehen. Es kann nicht für Felder, Methodenparameter oder Rückgabetypen verwendet werden. Auch var wert = null; ist nicht möglich, weil daraus kein konkreter Typ abgeleitet werden kann.

Typumwandlungen, Boxing und Unboxing

Bei einer erweiternden primitiven Konvertierung kann Java einen Wert automatisch in einen Typ mit passendem größerem Wertebereich überführen:

int stueckzahl = 42;
long grosseStueckzahl = stueckzahl;
double messwert = grosseStueckzahl;

Eine verengende Konvertierung muss ausdrücklich gecastet werden, weil Information verloren gehen kann:

double messwert = 19.95;
int ganzzahlig = (int) messwert; // Ergebnis: 19

long sehrGross = 3_000_000_000L;
int zuKlein = (int) sehrGross;   // Überlauf: anderer Zahlenwert

Wrapperklassen wie Integer, Long und Double stellen primitive Werte als Objekte dar. Java kann zwischen int und Integer häufig automatisch wechseln. Das heißt Autoboxing beziehungsweise Unboxing.

List zahlen = new ArrayList<>();
zahlen.add(7);              // Autoboxing: int -> Integer
int erste = zahlen.get(0); // Unboxing: Integer -> int

Arrays: mehrere Werte eines Typs

Ein Array speichert eine feste Anzahl von Elementen desselben Typs. Die Indizes beginnen bei 0; der letzte gültige Index ist daher length - 1.

int[] punkte = {12, 18, 24};

System.out.println(punkte[0]);      // 12
System.out.println(punkte.length);  // 3

for (int punkt : punkte) {
    System.out.println(punkt);
}

Die Länge eines Arrays kann nach der Erzeugung nicht geändert werden. Wenn Elemente dynamisch hinzukommen oder entfernt werden sollen, ist eine Collection wie ArrayList oft geeigneter.

Werte und Objekte richtig vergleichen

Bei primitiven Typen vergleicht == die Werte. Bei Referenztypen prüft ==, ob beide Variablen auf dasselbe Objekt verweisen. Für einen fachlichen Inhaltsvergleich wird normalerweise equals() verwendet.

String a = new String("Java");
String b = new String("Java");

System.out.println(a == b);      // false: verschiedene Objekte
System.out.println(a.equals(b)); // true: gleicher Inhalt

Wenn ein Wert null sein darf, ist Objects.equals(a, b) eine null-sichere Alternative. Bei eigenen Klassen solltest du equals() und hashCode() gemeinsam und konsistent implementieren – oder für reine Wertträger einen record prüfen.

Kurzvergleich mit Kotlin

Die Oberflächen unterscheiden sich, die grundlegenden Fragen bleiben gleich: Welchen Typ hat ein Wert, darf er fehlen, ist er veränderlich und welche Konvertierung ist beabsichtigt?

Best Practices und typische Fehler