Java-Datentypen: Primitive, Referenztypen und Standardwerte

Zwei Familien: Primitive und Referenzen

Jeder Wert in Java hat einen Typ, und dieser Typ gehört zu einer von zwei Familien. Primitive Typen speichern einen rohen Wert direkt: eine Zahl, ein einzelnes Zeichen oder ein Wahr/Falsch. Referenztypen speichern eine Referenz (einen Zeiger) auf ein Objekt, das anderswo im Speicher liegt: String, Arrays und jede Klasse, die du oder die Bibliotheken definierst.

Diese Unterscheidung ist wichtig, weil Primitive leichtgewichtig sind und als Wert kopiert werden, während Referenzvariablen auf gemeinsam genutzte Objekte zeigen. Beginne mit den acht Primitiven - sie sind das Fundament, auf dem alles andere aufbaut.

Die acht primitiven Typen

Java hat genau acht eingebaute primitive Typen. Sechs sind Zahlen, einer ist ein Zeichen, einer ist ein Boolean:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // 8-Bit-Ganzzahl,  -128 .. 127
        short  s = 30000;        // 16-Bit-Ganzzahl
        int    i = 2_000_000;    // 32-Bit-Ganzzahl (der Standard für ganze Zahlen)
        long   big = 9_000_000_000L; // 64-Bit-Ganzzahl - achte auf das L

        float  f = 3.14f;        // 32-Bit-Dezimalzahl - achte auf das f
        double d = 3.141592653589793; // 64-Bit-Dezimalzahl (der Standard für Dezimalzahlen)

        char   c = 'A';          // ein einzelnes 16-Bit-Unicode-Zeichen
        boolean flag = true;     // nur true oder false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

Ein paar Dinge, die von Anfang an auffallen sollten: Die Unterstriche in 2_000_000 sind nur optische Trennzeichen, die der Compiler ignoriert, die Suffixe L und f sind erforderlich (mehr dazu unten), und char verwendet einfache Anführungszeichen, während ein String doppelte Anführungszeichen verwenden würde.

Einen numerischen Typ wählen

byte oder short brauchst du fast nie - sie sparen nur in riesigen Arrays Speicher. Die echten Entscheidungen fallen zwischen int/long für ganze Zahlen und float/double für Dezimalzahlen.

Typ	Größe	Verwenden, wenn
int	32 Bit	Der Standard für ganze Zahlen (bis ~2,1 Milliarden)
long	64 Bit	Werte über ~2 Milliarden: Millisekunden-Zeitstempel, Dateigrößen
double	64 Bit	Der Standard für Dezimalzahlen - gute Genauigkeit
float	32 Bit	Nur wenn der Speicher knapp ist und die Genauigkeit leiden darf

Die Falle ist der Überlauf. Ein int läuft still über, wenn er seinen Bereich überschreitet - kein Fehler, nur eine falsche Antwort:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // läuft zu einer negativen Zahl über!

        long safe = (long) maxInt + 1;  // zuerst nach long hochstufen
        System.out.println(safe);
    }
}

maxInt + 1 läuft zu -2147483648 über, weil beide Operanden int sind und das Ergebnis ein int bleibt. Wenn man eine Seite zuerst nach long castet, wird die Berechnung in 64 Bit durchgeführt. Wenn ein Wert groß sein könnte - besonders Millisekunden seit 1970 - greife zu long.

Literale und ihre Suffixe

Ein nacktes Zahlenliteral hat einen Standardtyp, und das beißt einen. 100 ist ein int; 3.14 ist ein double. Um ein long- oder float-Literal zu schreiben, musst du ein Suffix hinzufügen:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // ohne L ist das zu groß für int -> Fehler
        float ratio = 0.5f;               // ohne f ist die rechte Seite ein double -> Fehler
        double pi = 3.14;                 // in Ordnung - Dezimalzahlen sind standardmäßig double

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Lass das L bei 8_000_000_000L weg, und der Code kompiliert nicht, weil das Literal den int-Bereich überschreitet, bevor es überhaupt die long-Variable erreicht. Lass das f bei 0.5f weg, und Java beschwert sich, dass ein double ohne Cast nicht einem float zugewiesen werden kann. Das Suffix ist nicht groß-/kleinschreibungsabhängig, aber verwende ein großes L - ein kleines l sieht genau wie die Ziffer 1 aus.

char ist eine getarnte Zahl

Ein char speichert eine 16-Bit-Unicode-Codeeinheit, was bedeutet, dass er zugleich als kleine vorzeichenlose Ganzzahl fungiert. Du kannst damit rechnen und ihn per Cast hin und her umwandeln:

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65 - der Unicode-Wert von 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

Das ist gelegentlich praktisch, um Buchstaben zu verschieben, aber verlass dich dabei nicht auf Text - dafür ist String da. Beachte, dass char einfache Anführungszeichen verwendet ('A'); doppelte Anführungszeichen ("A") erzeugen einen einzeichigen String, was ein völlig anderer Typ ist.

Standardwerte (und die Falle der lokalen Variablen)

Felder und Array-Elemente, die du nicht initialisierst, erhalten einen sinnvollen Standardwert. Aber das gilt nur für Felder und Array-Plätze: lokale Variablen erhalten keinen Standardwert, und eine zu verwenden, bevor man ihr einen Wert zuweist, ist ein Kompilierfehler, keine Überraschung zur Laufzeit.

public class Main {
    static int counter;        // Feld -> standardmäßig 0
    static boolean ready;      // Feld -> standardmäßig false
    static String name;        // Feld -> standardmäßig null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // Array-Elemente sind standardmäßig 0
        System.out.println(nums[0]); // 0
    }
}

Würdest du stattdessen int x; System.out.println(x); innerhalb von main schreiben, würde der Compiler es mit „variable x might not have been initialized" ablehnen. Diese Strenge ist ein Vorteil - sie hindert dich daran, Müll zu lesen. Die Standardwerte, die man sich merken sollte: numerische Typen 0, boolean false, char ' ' und jeder Referenztyp null.

Weiter: Strings

String ist der Referenztyp, mit dem du am häufigsten zu tun haben wirst: Text, zusammengefügte Werte, Benutzereingaben. Er verhält sich anders als die hier gezeigten Primitiven: Er ist ein Objekt, er ist unveränderlich (immutable), und das Vergleichen von Strings hat seine eigenen Tücken. Die nächste Seite behandelt ihn.