Kapitel 4: Variablen und Datentypen

🎯 Lernziele

In diesem Kapitel lernst du:

• Was Variablen sind und wofür man sie braucht
• Die verschiedenen Datentypen in Java (int, double, char, boolean, etc.)
• Wie man Variablen definiert und verwendet
• Namenskonventionen für Variablen (Identifier)
• Konstanten verwenden
• Datentypen konvertieren (automatisch & explizit)

4.1 Was sind Variablen? Wozu dienen sie?

📦 Variable = Datenspeicher

Stell dir eine Variable wie eine Schachtel vor:

• Du kannst etwas hineinlegen (Wert zuweisen)
• Du kannst den Inhalt ansehen (Wert auslesen)
• Du kannst den Inhalt ändern (neuen Wert zuweisen)

// Schachtel mit Namen "alter" erstellen und Wert 25 hineinlegen
int alter = 25;

// Inhalt ansehen
System.out.println(alter);  // Ausgabe: 25

// Inhalt ändern
alter = 26;
System.out.println(alter);  // Ausgabe: 26

🤔 Warum brauchen wir Variablen?

Ohne Variablen	Mit Variablen
System.out.println(25);	int alter = 25; System.out.println(alter);
Wert ist fest im Code	Wert kann sich ändern
Schwer zu warten	Leicht zu ändern

→ Variablen machen Programme flexibel!

4.2 Grundlegende Datentypen in Java

Java ist stark typisiert: Jede Variable muss einen Datentyp haben!

📊 Übersicht: Primitive Datentypen

Datentyp	Größe	Wertebereich	Beispiel
byte	8 Bit	-128 bis 127	byte alter = 25;
short	16 Bit	-32.768 bis 32.767	short jahr = 2024;
int	32 Bit	-2,1 Mrd. bis 2,1 Mrd.	int zahl = 100;
long	64 Bit	Sehr große Zahlen	long wert = 100L;
float	32 Bit	Gleitkommazahlen	float preis = 9.99f;
double	64 Bit	Präzise Gleitkommazahlen	double pi = 3.14159;
char	16 Bit	Einzelnes Zeichen	char buchstabe = 'A';
boolean	1 Bit	true oder false	boolean aktiv = true;

🔢 Ganze Zahlen (byte, short, int, long)

// int (am häufigsten verwendet)
int alter = 25;
int temperatur = -10;

// long (für sehr große Zahlen, mit 'L' suffix)
long bevoelkerung = 8000000000L;

// byte & short (seltener, für Speicheroptimierung)
byte kleineZahl = 100;
short mittlereZahl = 32000;

🔢 Gleitkommazahlen (float, double)

// double (Standard für Kommazahlen)
double preis = 19.99;
double pi = 3.14159265359;

// float (mit 'f' suffix)
float gewicht = 65.5f;

⚠️ Achtung: float braucht f am Ende, sonst Fehler!

🔤 Zeichen (char)

char buchstabe = 'A';
char ziffer = '9';
char sonderzeichen = '@';

→ Immer einzelnes Zeichen in einfachen Anführungszeichen!

✅/❌ Wahrheitswerte (boolean)

boolean istAktiv = true;
boolean hatBestanden = false;

// Wird oft in Bedingungen verwendet
if (istAktiv) {
    System.out.println("Aktiv!");
}

4.3 Variablen definieren und verwenden

📝 Syntax

// Syntax: datentyp variablenName = wert;

int alter = 25;
double gehalt = 3500.50;
char geschlecht = 'M';
boolean istVolljaehrig = true;

📋 Beispiel: Variablen nutzen

public class VariablenBeispiel {
    public static void main(String[] args) {
        // Variablen definieren
        int alter = 25;
        String name = "Max";
        double gehalt = 3500.50;
        boolean istAngestellt = true;
        
        // Variablen ausgeben
        System.out.println("Name: " + name);
        System.out.println("Alter: " + alter);
        System.out.println("Gehalt: " + gehalt + " €");
        System.out.println("Angestellt: " + istAngestellt);
    }
}

Ausgabe:

Name: Max
Alter: 25
Gehalt: 3500.5 €
Angestellt: true

🔄 Variablen-Werte ändern

int zahl = 10;
System.out.println(zahl);  // 10

zahl = 20;  // Wert ändern
System.out.println(zahl);  // 20

zahl = zahl + 5;  // Aktuellen Wert verwenden
System.out.println(zahl);  // 25

4.4 Namenskonventionen für Variablen (Identifier)

✅ Erlaubt (Regeln)

1. Dürfen enthalten: Buchstaben, Ziffern, _, $
2. Müssen beginnen mit: Buchstabe, _, $
3. Dürfen nicht beginnen mit: Ziffer
4. Dürfen kein Keyword sein: int, class, public etc.
5. Sind case-sensitive: alter ≠ Alter

✅ Gut (Empfohlene Konventionen)

// camelCase (für Variablen und Methoden)
int alterDesBenutzers = 25;
String vorname = "Max";
double monatsGehalt = 3500.50;

// Beschreibend (nicht zu kurz)
int a;  // ❌ Schlecht
int alter;  // ✅ Gut

❌ Falsch (Compiler-Fehler)

int 1zahl = 10;  // ❌ Darf nicht mit Ziffer beginnen
int class = 5;     // ❌ 'class' ist ein Keyword
int mein-name = 3; // ❌ Bindestrich nicht erlaubt

4.5 Konstanten verwenden

📌 Was sind Konstanten?

Konstanten sind Variablen, deren Wert nach der Initialisierung nicht mehr geändert werden kann.

🔒 Syntax: final Keyword

final datentyp KONSTANTEN_NAME = wert;

// Beispiele
final double PI = 3.14159;
final int MAX_ALTER = 100;
final String FIRMEN_NAME = "Meine Firma";

📋 Beispiel

public class KonstantenBeispiel {
    public static void main(String[] args) {
        final double PI = 3.14159;
        final int MAX_SPEED = 130;
        
        System.out.println("PI: " + PI);
        System.out.println("Max Geschwindigkeit: " + MAX_SPEED);
        
        // PI = 3.14;  // ❌ Fehler! Konstante kann nicht geändert werden
    }
}

📏 Konvention: Konstanten in GROSSBUCHSTABEN

→ MAX_SPEED statt maxSpeed

4.6 Datentyp-Konvertierung (automatisch & explizit)

🔄 Automatische Konvertierung (Implicit Casting)

Java konvertiert automatisch von "kleiner" zu "großer" Datentyp:

// Automatisch: byte → short → int → long → float → double
int i = 100;
long l = i;    // int → long (automatisch)
double d = l;   // long → double (automatisch)

// Beispiel
int alter = 25;
double alterDouble = alter;  // Automatisch: int → double
System.out.println(alterDouble);  // 25.0

⚠️ Explizite Konvertierung (Explicit Casting)

Wenn du von "groß" zu "klein" konvertieren willst, musst du manuell casten:

// Syntax: (zieldatentyp) wert

double preis = 19.99;
int preisInt = (int) preis;  // Explizit: double → int
System.out.println(preisInt);  // 19 (Nachkommastellen gehen verloren!)

// Weiteres Beispiel
long grosseZahl = 100L;
int kleineZahl = (int) grosseZahl;  // long → int (Achtung: Überlauf möglich!)

📊 Übersicht: Konvertierungsreihenfolge

Automatisch (implizit):
byte → short → int → long → float → double

Manuell (explizit / casten):
double → float → long → int → short → byte

🚨 Überlauf (Overflow) Achtung!

int maxInt = 2147483647;  // Max int Wert
maxInt = maxInt + 1;  // Überlauf!
System.out.println(maxInt);  // -2147483648 (Min int Wert!)

📝 Zusammenfassung

In diesem Kapitel hast du gelernt:

• ✅ Variablen sind Datenspeicher (wie Schachteln)
• ✅ Java hat 8 primitive Datentypen (int, double, char, boolean, etc.)
• ✅ Variablen-Namen müssen Regeln folgen (camelCase empfohlen)
• ✅ Konstanten mit final schützen Werte vor Änderung
• ✅ Automatische vs. explizite Konvertierung (Casting)

💡 Merksatz für Anfänger

"In Java muss jede Variable einen Datentyp haben. Nutze int für ganze Zahlen, double für Kommazahlen, und String für Text!"

🎯 Nächste Schritte

Im nächsten Kapitel lernst du:

• Operatoren (Kapitel 5)
• Arithmetische Operatoren (+, -, *, /, %)
• Zuweisungsoperatoren (=, +=, -=)
• Vergleichs- und Logikoperatoren

Bereit für Rechnungen? Los geht's! 🚀

---

📚 Weiterführende Links:

• Oracle Java Tutorials - Variables
• Java Primitive Data Types

💬 Fragen?
Hinterlasse einen Kommentar!