# Java Primitives: Alles über die Funktionsweise primitiver Datentypen Es gibt in Java acht primitive [Datentypen](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-data-types/), die eine feste Größe und einen definierten Wertebereich haben. Sie werden genutzt, um Variablen zu erstellen und diesen einzelne Zahlen, Zeichen oder logische Werte zuzuweisen. Die acht Java Primitives sind boolean, byte, char, double, float, int, long und short. ## Was sind Java Primitives? Wie in anderen Programmiersprachen gibt es auch unterschiedliche Java-Datentypen. Java definiert dabei zwei verschiedene Arten: Referenztypen verweisen auf ein Objekt, das frei definiert werden kann – Beispiele dafür sind u. a. Strings, Arrays, Klassen oder Interfaces. Daneben existieren Datentypen, die in Java „Primitives“ genannt werden. Diese haben eine **fest definierte Größe**, die auf allen Plattformen identisch ist. Sie verfügen alle über eine **eigene Wrapper-Klasse**, sind **unveränderlich eingebunden** und haben einen **fest definierten Wertebereich**. Java Primitives werden verwendet, um Variablen zu erstellen, die einzelne Zahlen, Zeichen oder logische Werte aufnehmen. In Java gibt es acht verschiedene primitive Datentypen, die so elementar sind, dass ihre Darstellung fest in der Programmiersprache verankert ist. Sie unterscheiden sich vor allem darin, **welche Werte sie speichern** können. Allen gemein ist, dass sie lediglich einen einzigen Wert enthalten. Da sich ihr jeweiliges Einsatzgebiet zumindest teilweise ähnelt, unterteilt man die Primitives in Java in vier Kategorien: - Logischer Datentyp (boolean) - Integraler Datentyp (byte, short, int und long) - Gleitkomma-Datentyp (float und double) - Zeichen-Datentyp (char) Da sie direkt im Stack gespeichert werden, kann ihre jeweilige Größe von entscheidender Bedeutung sein. Darauf gehen wir im weiteren Verlauf noch näher ein. Von großer Wichtigkeit sind die primitiven Datentypen aber auch, weil Java eine **statisch typisierte Sprache** ist. Wenn also ein Programm erstellt wird, muss bereits bekannt und festgelegt sein, welchen Datentyp eine Variable hat. Nur so kann der Code ohne Fehlermeldungen ausgeführt werden. Dies sind die Java Primitives auf einen Blick:
Datentyp Größe Wertebereich Standardwert Wrapper-Klasse
boolean 1 Bit true oder false false java.lang.Boolean
byte 8 Bit -128 bis 127 0 java.lang.Byte
short 16 Bit -32768 bis 32767 0 java.lang.Short
int 32 Bit -2147483648 bis 2147483647 0 java.lang.Integer
long 64 Bit -9223372036854775808 bis 9223372036854775807 0 java.lang.Long
float 32 Bit bis zu sieben Dezimalstellen 0,0 java.lang.Float
double 64 Bit bis zu 16 Dezimalstellen 0,0 java.lang.Double
char 16 Bit \*\*’\\u0000’ (also 0) bis ‘\\uffff’ (entspricht 65535) ‘\\u0000’ java.lang.Character
## boolean Der [Java Boolean](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-boolean/) ist auch als Wahrheitswert bekannt. Er ist der einfachste aller Primitives in Java, da er lediglich zwei mögliche Werte kennt: **„true“ oder „false“**. Er wird dann eingesetzt, wenn ein logischer Operand benötigt wird und gehört folglich alleine in die Gruppe der logischen Datentypen. In Ausdrücken stehen seine beiden möglichen Werte häufig für eine Bedingung, die entweder erfüllt ist (true) oder nicht (false). Weisen Sie einem Boolean keinen Wert zu, ist dieser automatisch false. Der Boolean kann mit booleschen Java-Operatoren wie [AND und OR](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-operators-and-or/) verwendet werden. Die Zuweisung funktioniert nach dem folgenden Prinzip: ```java public class Main { public static void main(String[] args) { boolean x = true; System.out.println(x); } } ``` Wenn Sie mit dem Java-Befehl `System.out.prinln` eine Ausgabe initiieren, sieht diese so aus: ```java true ``` ## byte byte ist die kleinste Option aus der Kategorie der integralen Datentypen. Er hat einen sehr eingeschränkten Wertebereich, der nur von **-128 bis 127** reicht. Dafür benötigt er allerdings auch nur 8 Bits Speicherplatz. Der Tatsache, dass 8 Bits einem Byte entsprechen, verdankt er seinen Namen. Wenn Sie nur von sehr begrenzten Werteoptionen ausgehen, können Sie byte folgendermaßen deklarieren: ```java public class Main { public static void main(String[] args) { byte x = 101; System.out.println(x); } } ``` Die Ausgabe sieht so aus: ```java 101 ``` ## short short ist **doppelt so groß wie byte**, gehört aber auch deshalb zu den Java Primitives, die eher selten verwendet werden. Wenn allerdings byte zu klein und int zu groß ist, können Sie diesen integralen Datentyp verwenden. Er wird so deklariert: ```java public class Main { public static void main(String[] args) { short x = -27412; System.out.println(x); } } ``` Die Ausgabe sieht folgendermaßen aus: ```java -27412 ``` ## int int ist der integrale Datentyp, der **am häufigsten verwendet** wird. Er hat einen sehr großen Wertebereich und ist dabei selbst noch vergleichsweise platzsparend. Der Zweierkomplement-Wert wird in vielen Fällen auch für weiterführende Anwendungen genutzt. So können Sie ihn einsetzen: ```java public class Main { public static void main(String[] args) { int x = 14; int y = 3; int z = x + y; System.out.println(x + " + " + y + " = " + z); } } ``` Dies ist die entsprechende Ausgabe: ```java 14 + 3 = 17 ``` ## long long ist eine Erweiterung von int und kann **noch größere Zahlenwerte** enthalten. In den meisten Fällen wird zwar int ausreichen, aber wenn Sie long deklarieren möchten, funktioniert dies so: ```java public class Main { public static void main(String[] args) { long x = 47; System.out.println(x); } } ``` Dies ist die passende Ausgabe: ```java 47 ``` ## float Wenn Sie Teilmengen von rationalen Zahlen darstellen möchten, gibt es zu diesem Zweck in Java zwei Primitives. float ist der kleinere der beiden **Gleitkomma-Datentypen** und braucht 32 Bits. Er kann bis zu sieben Dezimalstellen anzeigen. Er ist allerdings nicht sehr präzise und wird daher nur selten verwendet. Benötigen Sie ihn dennoch, wird er so deklariert: ```java public class Main { public static void main(String[] args) { float x = 7.22f; System.out.println(x); } } ``` Nach der Zahl wird ein kleines oder großes „f“ eingefügt, um dem Compiler anzuzeigen, dass es sich um float und nicht um double handelt. In der Ausgabe wird der Buchstabe nicht angezeigt: ```java 7.22 ``` ## double Der zweite Gleitkomma-Datentyp ist double. Er ist zwar wesentlich genauer als float, gibt aber dennoch keine völlig exakten Ergebnisse aus. Eine Alternative ist die **Klasse BigDecimal**. Sollte Ihnen double ausreichen, ist dies ein passendes Codebeispiel: ```java public class Main { public static void main(String[] args) { double x = 7.2252; System.out.println(x); } } ``` Auf die zusätzliche Ziffer können Sie dabei also verzichten. Dies ist die Ausgabe: ```java 7.2252 ``` ## char char wird genutzt, um ein Zeichen aus dem Unicode abzubilden. Dieser reicht von ‘\\u0000’ bis ‘\\uffff’, also von 0 bis 65535. Der Zeichen-Datentyp kann dadurch **fast alle europäischen und asiatischen Zeichen** darstellen. Diese benötigen jeweils 16 Bits Speicher. Die Werte dieses Primitives in Java werden in Hochkommata eingefasst. So sieht das im Code aus: ```java public class Main { public static void main(String[] args) { char x = '&'; System.out.println(x); } } ``` Dadurch erhalten Sie diese Ausgabe: ```java & ``` This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-primitives/](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-primitives/) for AI/LLM consumption.