Primitive Datentypen in Java

Java hat 8 primitive Datentypen — das sind die grundlegenden Bausteine fuer Zahlen, Wahrheitswerte und Zeichen. Im Gegensatz zu Python, wo es nur wenige Typen gibt, ist Java hier viel spezifischer. Das gibt dir mehr Kontrolle ueber Speicherverbrauch und Praezision.

Ueberblick: Alle 8 primitiven Typen

Typ	Groesse	Wertebereich	Standard	Beispiel
byte	1 Byte	-128 bis 127	0	byte b = 100;
short	2 Bytes	-32.768 bis 32.767	0	short s = 30000;
int	4 Bytes	-2,1 Mrd. bis 2,1 Mrd.	0	int i = 42;
long	8 Bytes	-9,2 Trillionen bis 9,2 Trillionen	0L	long l = 999999999L;
float	4 Bytes	ca. 7 Dezimalstellen	0.0f	float f = 3.14f;
double	8 Bytes	ca. 15 Dezimalstellen	0.0	double d = 3.14;
char	2 Bytes	Unicode-Zeichen (0-65535)	'\u0000'	char c = 'A';
boolean	1 Bit*	true oder false	false	boolean b = true;

*Die tatsaechliche Groesse von boolean haengt von der JVM-Implementierung ab.

Ganzzahlen: byte, short, int, long

int — Der Standard fuer Ganzzahlen

int ist der am haeufigsten verwendete Ganzzahltyp:

int alter = 25;
int einwohner = 83_000_000;   // Unterstriche fuer Lesbarkeit
int temperatur = -15;
int maximum = Integer.MAX_VALUE; // 2_147_483_647
int minimum = Integer.MIN_VALUE; // -2_147_483_648

Tipp: Du kannst Unterstriche (_) in Zahlen verwenden, um sie lesbarer zu machen. Java ignoriert sie.

long — Fuer grosse Zahlen

Wenn int nicht reicht (ueber 2,1 Milliarden), nimm long:

long weltbevoelkerung = 8_100_000_000L;  // L am Ende!
long distanzZumMond = 384_400_000L;       // in Metern
long nanosekunden = System.nanoTime();

Wichtig: Das L am Ende ist Pflicht, sonst denkt Java, es sei ein int.

byte und short — Selten benoetigt

byte kleineZahl = 127;     // Max: 127
short mittlereZahl = 32_000; // Max: 32_767

Diese Typen sind vor allem fuer speicheroptimierte Anwendungen relevant (z.B. grosse Arrays mit Millionen Eintraegen). Fuer den Alltag reicht int.

Ganzzahl-Ueberlauf

Was passiert, wenn eine Zahl zu gross wird?

int max = Integer.MAX_VALUE; // 2_147_483_647
System.out.println(max + 1); // -2_147_483_648 -- Ueberlauf!

Java warnt dich nicht vor einem Ueberlauf! Der Wert springt einfach zum Minimum. Wenn du grosse Zahlen brauchst, verwende long oder BigInteger.

Dezimalzahlen: float und double

double — Der Standard fuer Dezimalzahlen

double pi = 3.141592653589793;
double temperatur = 36.6;
double preis = 29.99;
double negativ = -0.5;

float — Weniger Praezision, weniger Speicher

float piFloat = 3.1415927f;  // f am Ende!
float preisFloat = 29.99f;

double vs. float

Eigenschaft	float	double
Groesse	4 Bytes	8 Bytes
Praezision	~7 Stellen	~15 Stellen
Suffix	f (Pflicht)	keins
Verwendung	Selten (Grafik, ML)	Standard

float f = 1.0f / 3.0f;
double d = 1.0 / 3.0;

System.out.println(f);  // 0.33333334
System.out.println(d);  // 0.3333333333333333

Achtung: Fliesskomma-Ungenauigkeit

System.out.println(0.1 + 0.2);        // 0.30000000000000004
System.out.println(0.1 + 0.2 == 0.3); // false!

Das ist kein Java-Bug — alle Programmiersprachen haben dieses Problem (auch Python!). Fuer Geldbetraege verwende BigDecimal:

import java.math.BigDecimal;

var preis1 = new BigDecimal("0.10");
var preis2 = new BigDecimal("0.20");
var summe = preis1.add(preis2);

System.out.println(summe);              // 0.30
System.out.println(summe.equals(new BigDecimal("0.30"))); // true

Wahrheitswerte: boolean

boolean istVolljährig = true;
boolean hatBestanden = false;
boolean istGroesser = 10 > 5;       // true
boolean sindGleich = "abc".equals("abc"); // true

boolean kann nur true oder false sein — keine Zahlen, keine Strings:

// GEHT NICHT (anders als in Python/JavaScript):
// boolean b = 1;        // Fehler!
// boolean b = "true";   // Fehler!
// if (1) { }            // Fehler!

// RICHTIG:
boolean b = true;
if (b) { }

Vergleich mit Python

# Python: Viele Werte sind "truthy" oder "falsy"
if 1:         # True
if "":        # False
if []:        # False
if None:      # False

// Java: Nur boolean erlaubt
if (true)     // OK
// if (1)     // FEHLER!
// if ("")    // FEHLER!
// if (null)  // FEHLER!

Zeichen: char

char speichert ein einzelnes Unicode-Zeichen:

char buchstabe = 'A';
char ziffer = '9';
char sonderzeichen = '#';
char emoji = '\u2764';  // Herz-Symbol
char newline = '\n';    // Zeilenumbruch

Wichtig: char verwendet einfache Anfuehrungszeichen ('A'), Strings verwenden doppelte ("Hallo").

Escape-Sequenzen

Sequenz	Bedeutung
\n	Zeilenumbruch
\t	Tabulator
\\	Backslash
\'	Einfaches Anfuehrungszeichen
\"	Doppeltes Anfuehrungszeichen

System.out.println("Zeile 1\nZeile 2");
System.out.println("Name:\tMax");
System.out.println("Er sagte: \"Hallo!\"");

Wrapper-Klassen

Fuer jeden primitiven Typ gibt es eine Wrapper-Klasse (Referenztyp):

Primitiv	Wrapper	Beispiel
int	Integer	Integer.parseInt("42")
double	Double	Double.parseDouble("3.14")
boolean	Boolean	Boolean.parseBoolean("true")
char	Character	Character.isLetter('A')
long	Long	Long.MAX_VALUE
float	Float	Float.isNaN(0.0f/0.0f)
byte	Byte	Byte.MAX_VALUE
short	Short	Short.parseShort("100")

Warum Wrapper-Klassen?

1. Collections koennen nur Referenztypen speichern:

// GEHT NICHT:
// List<int> zahlen = List.of(1, 2, 3);

// GEHT:
List<Integer> zahlen = List.of(1, 2, 3);

2. Nuetzliche Methoden:

int max = Integer.MAX_VALUE;          // 2147483647
int zahl = Integer.parseInt("42");    // String -> int
String hex = Integer.toHexString(255); // "ff"
boolean istZiffer = Character.isDigit('5'); // true

Autoboxing und Unboxing

Java konvertiert automatisch zwischen primitiven Typen und Wrappern:

// Autoboxing: int -> Integer
Integer zahl = 42;  // Java macht: Integer.valueOf(42)

// Unboxing: Integer -> int
int wert = zahl;    // Java macht: zahl.intValue()

Typkonvertierung im Detail

Implizite Konvertierung (kein Datenverlust)

byte b = 42;
short s = b;    // byte -> short: OK
int i = s;      // short -> int: OK
long l = i;     // int -> long: OK
float f = l;    // long -> float: OK (aber Praezisionsverlust moeglich!)
double d = f;   // float -> double: OK

Explizite Konvertierung (moeglicher Datenverlust)

double d = 9.99;
int i = (int) d;      // 9 (Nachkommastellen weg)

long l = 3_000_000_000L;
int j = (int) l;       // Ueberlauf! Falsches Ergebnis

int k = 65;
char c = (char) k;     // 'A' (ASCII-Code 65)

Praktische Beispiele

Temperaturumrechner

public class TemperaturRechner {
    public static void main(String[] args) {
        double celsius = 36.6;
        double fahrenheit = celsius * 9.0 / 5.0 + 32;
        double kelvin = celsius + 273.15;

        System.out.printf("%.1f°C = %.1f°F = %.2f K%n", celsius, fahrenheit, kelvin);
    }
}

Speichergroesse berechnen

public class Speicher {
    public static void main(String[] args) {
        long dateienAnzahl = 10_000;
        long durchschnittsGroesse = 5_000_000L; // 5 MB
        long gesamtGroesse = dateienAnzahl * durchschnittsGroesse;

        System.out.printf("Gesamtgroesse: %d Bytes%n", gesamtGroesse);
        System.out.printf("Das sind: %.2f GB%n", gesamtGroesse / 1_073_741_824.0);
    }
}

Uebungen

Uebung 1: Datentypen zuordnen

Welchen Datentyp wuerdest du fuer folgende Werte waehlen?

• Die Anzahl deiner Haustiere
• Der Preis eines Produkts
• Ob ein Benutzer eingeloggt ist
• Die Weltbevoelkerung
• Dein Anfangsbuchstabe

Uebung 2: Ueberlauf testen

Schreibe ein Programm, das Integer.MAX_VALUE ausgibt und dann 1 addiert. Was passiert? Wiederhole das mit Long.MAX_VALUE.

Uebung 3: Umrechner

Schreibe ein Programm, das Kilometer in Meilen umrechnet (1 km = 0.621371 Meilen). Lies den Kilometerstand vom Benutzer ein.

Uebung 4: ASCII-Tabelle

Schreibe ein Programm, das die ASCII-Zeichen von 65 bis 90 (A-Z) mit ihren Codes ausgibt:

65 -> A
66 -> B
...

Was kommt als Naechstes?

In der naechsten Lektion widmen wir uns ganz dem Thema Strings — dem wohl wichtigsten Referenztyp in Java. Du lernst String-Methoden, Vergleiche, StringBuilder und die modernen Text Blocks.

Zusammenfassung

• Java hat 8 primitive Datentypen: byte, short, int, long, float, double, char, boolean
• int ist der Standard fuer Ganzzahlen, double fuer Dezimalzahlen
• Unterstriche machen grosse Zahlen lesbarer: 1_000_000
• Wrapper-Klassen (Integer, Double, etc.) bieten nuetzliche Methoden
• Autoboxing konvertiert automatisch zwischen primitiven und Wrapper-Typen
• Fliesskommazahlen sind nicht exakt — fuer Geld nutze BigDecimal
• Casting mit (typ) konvertiert explizit, aber Vorsicht vor Datenverlust

---