Variablen und primitive Typen

Ein Programm arbeitet mit Werten: Zahlen, Zeichen, Wahrheitswerten, Texten. Damit es sich diese Werte merken kann, braucht es Variablen.

Was du am Ende kannst

• Variablen deklarieren, initialisieren und ändern
• den passenden primitiven Typ für einen Wert wählen
• erklären, warum Integer.MAX_VALUE + 1 negativ ist
• zwischen Typen umwandeln und Konstanten verwenden

Projekt für dieses Kapitel

Lege in Eclipse das Projekt 03-variablen an – wie in Arbeiten mit Eclipse, also ohne module-info.java – und darin das Package de.drv. Für jedes Beispiel legst du dort eine eigene Klasse mit main-Methode an.

Was ist eine Variable?

Eine Variable ist ein benannter Speicherplatz für einen Wert. In Java hat jede Variable einen Typ, der festlegt, welche Art von Werten hineinpasst. Dieser Typ steht fest und kann sich später nicht mehr ändern – Java ist eine statisch typisierte Sprache.

Variablen.java

package de.drv;

public class Variablen {

    public static void main(String[] args) {
        int alter;
        alter = 19;
        System.out.println(alter);

        int jahr = 2026;
        System.out.println("Geburtsjahr: " + (jahr - alter));

        alter = alter + 1;
        System.out.println("Nächstes Jahr: " + alter);
    }

}

19
Geburtsjahr: 2007
Nächstes Jahr: 20

Drei Dinge passieren hier:

Begriff	Beispiel	Bedeutung
Deklaration	int alter;	Eine Variable mit Typ int und Namen alter wird angelegt.
Zuweisung	alter = 19;	Der Variable wird ein Wert gegeben.
Initialisierung	int jahr = 2026;	Deklaration und erste Zuweisung in einem Schritt.

Das Gleichheitszeichen = ist in Java keine Gleichung, sondern eine Zuweisung: „Rechne den Ausdruck rechts aus und speichere das Ergebnis in der Variable links.“ Deshalb ist alter = alter + 1; völlig sinnvoll: Nimm den alten Wert, addiere 1, speichere das Ergebnis.

Erst zuweisen, dann lesen

Eine Variable, die noch keinen Wert hat, darf nicht gelesen werden. Eclipse meldet sonst: The local variable alter may not have been initialized.

Die acht primitiven Typen

Java kennt acht eingebaute, sogenannte primitive Typen:

Typ	Größe	Wertebereich bzw. Inhalt	Beispiel
byte	8 Bit	−128 bis 127	byte b = 100;
short	16 Bit	−32.768 bis 32.767	short s = 30_000;
int	32 Bit	ca. ±2,1 Milliarden	int anzahl = 42;
long	64 Bit	ca. ±9,2 Trillionen	long l = 8_200_000_000L;
float	32 Bit	Kommazahl, ca. 7 Stellen genau	float f = 19.99f;
double	64 Bit	Kommazahl, ca. 15–16 Stellen genau	double preis = 19.99;
char	16 Bit	ein Zeichen (Unicode)	char c = 'J';
boolean	–	true oder false	boolean ok = true;

Im Alltag brauchst du fast nur die fett gedruckten: int für ganze Zahlen, double für Kommazahlen, boolean für Ja/Nein und char für einzelne Zeichen. Reicht int nicht aus, nimmst du long.

Typen.java

package de.drv;

public class Typen {

    public static void main(String[] args) {
        int anzahl = 2_000_000_000;
        long weltbevoelkerung = 8_200_000_000L;
        double preis = 19.99;
        char buchstabe = 'J';
        boolean istVolljaehrig = true;

        System.out.println("anzahl: " + anzahl);
        System.out.println("weltbevoelkerung: " + weltbevoelkerung);
        System.out.println("preis: " + preis);
        System.out.println("buchstabe: " + buchstabe);
        System.out.println("istVolljaehrig: " + istVolljaehrig);
    }

}

Literale

Ein Wert, der direkt im Quelltext steht, heißt Literal. Ein paar Regeln:

• Ganze Zahlen wie 42 sind vom Typ int. Für long hängst du ein L an: 8_200_000_000L.
• Kommazahlen schreibst du mit Punkt: 19.99. Sie sind vom Typ double. Für float hängst du ein f an: 19.99f.
• Unterstriche machen große Zahlen lesbar: 2_000_000_000 – Java ignoriert sie.
• Ein Zeichen steht in einfachen Anführungszeichen: 'J'. Text steht in doppelten: "Ja" – das ist kein char, sondern ein String (siehe unten).

Grenzen

Jeder Typ hat eine feste Größe – und damit Grenzen. Was passiert, wenn man sie überschreitet?

Grenzen.java

package de.drv;

public class Grenzen {

    public static void main(String[] args) {
        int max = Integer.MAX_VALUE;
        System.out.println(max);
        System.out.println(max + 1);

        System.out.println(0.1 + 0.2);
    }

}

2147483647
-2147483648
0.30000000000000004

Überlauf: Rechnet man über den größten int-Wert hinaus, springt das Ergebnis ohne Warnung ans andere Ende des Wertebereichs. Java meldet keinen Fehler – das Ergebnis ist einfach falsch.

Ungenauigkeit: Kommazahlen werden intern im Binärsystem gespeichert. Viele Dezimalzahlen wie 0.1 lassen sich dort nicht exakt darstellen – wie 1/3 im Dezimalsystem. Kleine Rundungsfehler sind die Folge.

Kein double für Geldbeträge

Für Beträge, bei denen jeder Cent zählt, ist double ungeeignet. Dafür gibt es die Klasse BigDecimal – die lernen wir später kennen. Bis dahin rechnen wir zum Üben mit double.

Typumwandlung

Manchmal muss ein Wert von einem Typ in einen anderen.

Umwandlung.java

package de.drv;

public class Umwandlung {

    public static void main(String[] args) {
        int ganz = 7;
        double komma = ganz;
        System.out.println(komma);

        double wert = 3.99;
        int abgeschnitten = (int) wert;
        System.out.println(abgeschnitten);

        char c = 'A';
        int code = c;
        System.out.println(code);
        System.out.println((char) (c + 1));
    }

}

7.0
3
65
B

• Vom kleineren zum größeren Typ (z. B. int → double) geht automatisch: Es kann nichts verloren gehen.
• Vom größeren zum kleineren Typ (z. B. double → int) musst du ausdrücklich verlangen – mit einem Cast: (int) wert. Dabei werden die Nachkommastellen abgeschnitten, nicht gerundet. Ohne Cast meldet Eclipse: Type mismatch: cannot convert from double to int.
• Ein char ist intern eine Zahl: der Code des Zeichens. 'A' hat den Code 65, 'B' den Code 66 – deshalb kann man mit Zeichen rechnen.

Konstanten

Werte, die sich nie ändern sollen, markierst du mit final:

final double MWST_SATZ = 0.19;
double netto = 100.0;
double brutto = netto * (1 + MWST_SATZ);

Versucht jemand später, MWST_SATZ einen neuen Wert zu geben, meldet Eclipse einen Fehler. Konstanten schreibt man nach Konvention in Großbuchstaben mit Unterstrichen.

Und Texte?

Für Texte gibt es den Typ String:

String name = "Anna";
System.out.println("Hallo " + name);

String ist kein primitiver Typ, sondern eine Klasse – deshalb wird er großgeschrieben. Wir benutzen ihn ab jetzt ganz selbstverständlich; was eine Klasse genau ist, besprechen wir später.

var

Seit Java 10 darfst du bei lokalen Variablen den Typ weglassen, wenn er sich aus dem Wert ergibt:

var anzahl = 42;        // int
var preis = 19.99;      // double
var name = "Anna";      // String

Die Variable hat trotzdem einen festen Typ – Java leitet ihn nur selbst ab. In dieser Schulung schreiben wir die Typen vorerst aus: Am Anfang hilft es, sie immer vor Augen zu haben.

Namen für Variablen

Regeln – sonst meldet der Compiler einen Fehler:

• Buchstaben, Ziffern, _ und $; keine Ziffer am Anfang
• Groß- und Kleinschreibung zählt: alter und Alter sind verschiedene Variablen
• keine reservierten Wörter wie int, class oder public

Konventionen – daran hält sich praktisch jeder Java-Code:

• Variablen in lowerCamelCase: anzahlTeilnehmer, istVolljaehrig
• Konstanten in UPPER_SNAKE_CASE: MWST_SATZ
• sprechende Namen statt x, a2 oder temp
• Umlaute sind erlaubt, aber unüblich – wir schreiben ae, oe, ue

Wenn es nicht klappt

Meldung in Eclipse	Ursache
The local variable x may not have been initialized	Variable gelesen, bevor sie einen Wert hat
Type mismatch: cannot convert from double to int	Kommazahl in int-Variable – Cast nötig: (int)
The literal 3000000000 of type int is out of range	Zahl zu groß für int – L anhängen und long verwenden
Duplicate local variable x	Variable mit diesem Namen gibt es schon
The final local variable X cannot be assigned	Einer Konstante wird ein neuer Wert zugewiesen

Übungen

1. Berechne die Sekunden eines Jahres (365 Tage) und gib sie aus.

2. Berechne jetzt die Millisekunden eines Jahres: long ms = 365 * 24 * 60 * 60 * 1000; Das Ergebnis ist falsch, obwohl ms ein long ist. Warum? Wie behebst du es?

3. Rechne eine Temperatur von Celsius in Fahrenheit um: fahrenheit = celsius * 9 / 5 + 32. Probiere 21,5 °C.

4. Welchen Zeichencode hat 'a'? Gib ausgehend von 'a' den Buchstaben 'e' aus, ohne 'e' hinzuschreiben.

5. Gegeben sind int a = 3; und int b = 8;. Vertausche die Werte, sodass danach a 8 und b 3 ist.