Variablen und Datentypen.

Eine Variable ist ein Name, über den ein Wert bzw. ein Objekt erreichbar ist. Bei Java-Primitiven steht der Wert direkt in der Variable; bei Java-Objekten enthält die Variable eine Referenz auf das Objekt. In Python bindet ein Name an ein Objekt, das Objekt hat den Typ, nicht der Name. Du lernst hier, welche Grundtypen (int, double, boolean, String/char) du in Klausuren sicher beherrschen musst, welcher Wertebereich für welchen Typ gilt, wann eine Konvertierung (Widening vs Narrowing, expliziter Cast) erlaubt ist und worin sich primitive Datentypen von Referenz-Typen unterscheiden. Das ist Pflichtstoff im 1. Semester Informatik, Wirtschaftsinformatik und allen verwandten Studiengängen.

Bevor wir ins Beispiel gehen, eine zentrale Unterscheidung: Primitive Typen speichern Werte direkt (die 21 liegt im Speicherbereich der Variable selbst), Referenz-Typen speichern eine Referenz auf ein Objekt (eine Art "Verweis", der zur Laufzeit von der JVM auf eine Speicheradresse aufgelöst wird; das Objekt selbst lebt woanders im Heap). Diese Unterscheidung erklärt, warum z.B. == bei Strings unzuverlässig ist und warum final nicht gleich "unveränderlich" bedeutet.

Mini-Beispiel, das die ganze Logik in vier Zeilen zeigt:

int alter = 21;          // Java: Typ vorne, Wert (21) liegt direkt im Speicher
String name = "Anna";    // Java: String ist KEIN primitiver Typ -> Variable hält Referenz aufs Objekt

Eine Variable ist im Grunde ein Container mit einem Namen (dem Identifier), durch den du auf einen Wert zugreifen kannst. Vier Dinge stecken in dieser Mini-Szene drin:

1. Name: alter bzw. name (was du im Code schreibst, der Identifier der Variable)
2. Typ: int (primitiver Typ, 32-bit) bzw. String (Klasse)
3. Wert: 21 bzw. "Anna"
4. Speicher-Form: bei int steht die 21 direkt in der Variable. Bei String enthält name nur eine Referenz, das eigentliche Anna-Objekt liegt im Heap.

Eine spätere Zuweisung alter = 22; ersetzt den Wert. Ein name = "Ben"; lässt das Anna-Objekt unangetastet und biegt die Referenz auf ein neues String-Objekt um.

 alter  ─►┌────┐         name  ─►┌─ref─┐         ┌────────────┐
          │ 21 │                 │  *──┼────────►│ "Anna"     │
          └────┘                 └─────┘         └────────────┘
   Primitive: Wert liegt          Reference: Variable hält Adresse,
   direkt in der Variable         Objekt liegt im Heap

Die wichtigsten Datentypen, die du in der Klausur kennen musst:

• int: Ganzzahl, z.B. 42 oder -7. In Java 32-bit (Wertebereich -2^(31) bis 2^(31)-1). Für größere ganze Zahlen: long (64-bit). Weitere primitive Integer-Typen: byte (8-bit), short (16-bit).
• float / double: Kommazahlen. Java-Standard ist double (64-bit Gleitkomma). float ist nur 32-bit, weniger genau, und Java-Literale wie 3.14 sind standardmäßig double. Für float muss man 3.14f schreiben oder einen expliziten Cast (englisch explicit cast, schreibt den Ziel-Typ in Klammern vor den Wert, z.B. (float) 3.14) verwenden.
• boolean: Wahrheitswert, true oder false
• char (Java): einzelner 16-bit UTF-16-Code-Unit, z.B. 'a' (mit einfachen Anführungszeichen)
• String: Zeichenkette, z.B. "Hallo" (Anführungszeichen)

Java ist statisch typisiert: Typ wird beim Deklarieren festgelegt und bleibt fest. Python ist dynamisch typisiert: der Name wird zur Laufzeit an ein Objekt gebunden, und derselbe Name kann später an ein Objekt mit anderem Typ gebunden werden. In der Klausur wirst du oft gefragt: welcher Typ passt für welchen Wert? und kann ich diesen Wert in jenen Typ konvertieren ohne Datenverlust?

Deklaration

In Java muss jede Variable einen Typ haben, in Python wird der Typ automatisch erkannt.

int alter = 21;
String name = "Anna";
double note = 1.7;
boolean bestanden = true;

alter = 21
name = "Anna"
note = 1.7
bestanden = True

Wichtige Datentypen

Weitere Java-Primitive: byte (8-bit), short (16-bit), long (64-bit, Literal mit L-Suffix), char (16-bit UTF-16).

Faustregel zur Typ-Wahl: Für ganze Zahlen nutze fast immer int. Nur bei extrem großen Zahlen (über 2 Mrd.) wähle long. byte und short sind Spezialkandidaten für hardware-nahe oder speicher-kritische Situationen (Embedded-Systeme, große Datenmengen mit fester Bit-Breite), kommen in Standard-BWL/Info-Klausuren selten vor. char brauchst du nur wenn du wirklich genau ein Zeichen meinst, sonst lieber String.

Konvertierungen: Widening vs Narrowing

WIDENING (implizit erlaubt, KEINE Compile-Errors):
   byte  →  short  →  int  →  long  →  float  →  double
            (1)              (2)              (3)
   (1) auch char → int direkt erlaubt
   (2) int → float: Präzisionsverlust möglich (float-Mantisse 24 Bit
       effektiv, int hat 32 Bit Nutzdaten). int → double ist dagegen
       VERLUSTFREI (double-Mantisse 53 Bit effektiv reicht für jeden int).
   (3) long → float und long → double: Präzisionsverlust möglich
       (long hat 64 Bit, double-Mantisse nur 53 Bit effektiv)

NARROWING (expliziter Cast nötig, Datenverlust möglich):
   double  →  float  →  long  →  int  →  short  →  byte
   Beispiel: int x = (int) 3.7;   // Ergebnis: 3 (Truncation, kein Runden)

Welche Widening-Konvertierungen sind verlustfrei, welche nicht?

Java erlaubt diese Konvertierungen alle implizit OHNE Cast (kein Compile-Error), aber bei den ⚠️-Fällen bekommst du eine gerundete Approximation statt des exakten Werts. Hinweis zur Mantisse: IEEE-754 nutzt einen impliziten führenden 1-Bit, also 23 gespeicherte + 1 implizit = 24 effektive Mantissen-Bits bei float bzw. 52 + 1 = 53 bei double.

Normale Variablen können neu zugewiesen werden. Ausnahmen:

• Java final: final int x = 5;, x kann nicht neu zugewiesen werden.
• Mutability vs. Reassignment: Auch ohne final muss man unterscheiden zwischen "den Namen auf ein anderes Objekt zeigen lassen" (Reassignment) und "das Objekt selbst verändern" (Mutation). In Python sind int, str, tuple z. B. unveränderlich (immutable), aber der Name kann an ein neues Objekt gebunden werden.

In statisch typisierten Sprachen wie Java bleibt der Typ einer Variable fest: aus einem int wird kein String. In dynamisch typisierten Sprachen wie Python kannst du denselben Namen später für einen anderen Typ wiederverwenden, was Flexibilität gibt, aber auch Fehlerquellen.

Variable selbst ausprobieren

Wähle einen Typ, gib einen Wert ein und schau wie Java reagiert. Probier auch Python, dort wird der Typ automatisch erkannt.

Tipp: Versuch mal in Java den Typ int und gib 3.14 ein. Java akzeptiert das nicht (kein Integer). In Python klappt das problemlos: x ist nicht vorher als int festgelegt, x = 3.14 bindet den Namen x an ein neues float-Objekt. In Python wird x also nicht zu einem int mit Dezimalstellen (das gibt es nicht), sondern zeigt danach einfach auf ein anderes Objekt mit anderem Typ.

---

Code-Stepper: Schritt für Schritt durchspielen

Vier interaktive Demos zu den klassischen Klausur-Themen rund um Datentypen: Int-Overflow, Cast widening/narrowing, Primitive vs Reference im Speicher, und Pythons dynamische Typisierung. Klick Step oder Auto und beobachte, wie sich Variablen verändern.

1. Int-Overflow: warum 1_500_000_000 × 2 negativ wird

2. Cast: int → double → int (Widening + Narrowing)

Widening (implizit erlaubt ohne Cast) vs. Narrowing (expliziter Cast nötig, Datenverlust möglich). Beobachte den pi-Truncation-Schritt.

3. Primitive vs Reference: Wert kopieren vs Adresse kopieren

Klassiker: y = x mit primitiven Werten kopiert den Wert. b = a mit String-Referenzen kopiert die Adresse, beide zeigen aufs selbe Objekt, bis man eine Referenz umbiegt.

4. Python dynamic typing: derselbe Name, drei verschiedene Typen

In Python gehört der Typ zum Objekt, nicht zum Namen. Du kannst denselben Namen über die Zeit an Objekte unterschiedlicher Typen binden.