Tag 5 : Konstanten & Static 🔴 KOPFNUSS

Von Nova Trent, Junior Entwicklerin bei Java Fleet Systems Consulting

Schwierigkeit: 🔴 KOPFNUSS (anspruchsvoller!)
Lesezeit: 35–40 Minuten
Voraussetzungen: Tag 1–4 abgeschlossen

---

📋 Kursübersicht: Java OOP in 10 Tagen

Tag	Thema	Status
1	OOP-Konzepte & erste Klasse	✅ Abgeschlossen
2	Attribute & Methoden	✅ Abgeschlossen
3	Datenkapselung & Sichtbarkeit	✅ Abgeschlossen
4	Konstruktoren	✅ Abgeschlossen
→ 5	Konstanten & Static	📍 Du bist hier 🔴
6	Vererbung – Grundlagen	⏳
7	Vererbung – Polymorphie & Abstrakte Klassen	⏳
8	Typumwandlung & instanceof	⏳
9	Interfaces & Enumerationen	⏳
10	Ausnahmebehandlung	🔴 KOPFNUSS

Voraussetzung: Tag 1–4 abgeschlossen
Hinweis: Dieser Tag ist als KOPFNUSS markiert — nimm dir Zeit!

---

🔄 Kurz-Wiederholung: Challenge von Tag 4

Die Aufgabe war: Erstelle eine Mitarbeiter-Klasse mit Konstruktor-Verkettung.

Lösung:

public class Mitarbeiter {
    private final String personalnummer;
    private String name;
    private String abteilung;
    private double gehalt;
    
    // HAUPTKONSTRUKTOR
    public Mitarbeiter(String personalnummer, String name, String abteilung, double gehalt) {
        // Personalnummer validieren: P + 4 Ziffern
        if (personalnummer == null || !personalnummer.matches("P\\d{4}")) {
            throw new IllegalArgumentException(
                "Personalnummer muss Format 'P1234' haben!"
            );
        }
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name darf nicht leer sein!");
        }
        if (gehalt < 1500) {
            throw new IllegalArgumentException("Gehalt muss mindestens 1500€ sein!");
        }
        
        this.personalnummer = personalnummer;
        this.name = name;
        this.abteilung = abteilung;
        this.gehalt = gehalt;
    }
    
    // Konstruktor 2: Gehalt = 3000€
    public Mitarbeiter(String personalnummer, String name, String abteilung) {
        this(personalnummer, name, abteilung, 3000.0);
    }
    
    // Konstruktor 3: Abteilung = "Allgemein", Gehalt = 3000€
    public Mitarbeiter(String personalnummer, String name) {
        this(personalnummer, name, "Allgemein");
    }
    
    // Getter...
    public String getPersonalnummer() { return personalnummer; }
    public String getName() { return name; }
    public String getAbteilung() { return abteilung; }
    public double getGehalt() { return gehalt; }
}

Hast du’s? Super! Heute wird’s konzeptuell anspruchsvoller — aber du schaffst das!

---

⚡ Das Wichtigste in 30 Sekunden

Dein Problem: Manche Werte gehören nicht zu einzelnen Objekten, sondern zur Klasse selbst — z.B. ein Zähler für alle erstellten Objekte oder mathematische Konstanten wie PI.

Die Lösung: static für Klassen-Eigenschaften, final für unveränderliche Werte, static final für echte Konstanten.

Heute lernst du:

• ✅ static — Variablen und Methoden, die zur Klasse gehören
• ✅ final — Werte, die nicht geändert werden können
• ✅ static final — echte Konstanten (SCREAMING_SNAKE_CASE)
• ✅ Wann static und wann nicht?

Für wen ist dieser Artikel?

• 🌱 OOP-Neulinge: Du lernst das Konzept von Grund auf
• 🌿 OOP-Umsteiger: Du siehst Java vs. C#/C++ Unterschiede
• 🌳 Profis: Im Bonus: Static Initializer, Singleton, Utility-Klassen

Zeit-Investment: 35–40 Minuten (KOPFNUSS!)

---

👋 Nova: „Das hat mich am Anfang verwirrt…“

Hey! 👋

Nova hier.

Real talk: static hat mich am Anfang komplett verwirrt. „Was heißt das, die Variable gehört zur Klasse?! Klassen sind doch nur Baupläne?!“

Aber dann hat Elyndra mir ein Beispiel gezeigt, das klick gemacht hat:

Stell dir eine Autofabrik vor. Jedes Auto (Objekt) hat seine eigene Farbe und PS-Zahl. Aber die Fabrik (Klasse) zählt, wie viele Autos insgesamt produziert wurden. Dieser Zähler gehört nicht zu einem einzelnen Auto — er gehört zur Fabrik selbst.

Das ist static: Etwas, das zur Klasse gehört, nicht zu den einzelnen Objekten.

Heute zeige ich dir:

• Wann du static brauchst
• Wann du es NICHT verwenden solltest
• Wie du echte Konstanten definierst

Achtung: Das ist ein KOPFNUSS-Tag. Nimm dir Zeit, lies langsam, und mach Pausen wenn nötig. 🧠

Los geht’s! 🚀

---

🟢 GRUNDLAGEN

Das Problem: Gemeinsame Daten für alle Objekte

Stell dir vor, du willst zählen, wie viele Auto-Objekte erstellt wurden:

public class Auto {
    private String farbe;
    private int ps;
    private int autoNummer;  // Welches Auto ist das?
    
    public Auto(String farbe, int ps) {
        this.farbe = farbe;
        this.ps = ps;
        // Wie bekomme ich die nächste Nummer?! 🤔
    }
}

Wo speicherst du den Zähler? Jedes Auto hat seine eigene Kopie von autoNummer, aber wer weiß, wie viele Autos es insgesamt gibt?

Die Lösung: static

public class Auto {
    // STATIC: Gehört zur KLASSE, nicht zum Objekt!
    private static int anzahlAutos = 0;
    
    private String farbe;
    private int ps;
    private final int autoNummer;
    
    public Auto(String farbe, int ps) {
        this.farbe = farbe;
        this.ps = ps;
        
        anzahlAutos++;  // Klassenvariable erhöhen
        this.autoNummer = anzahlAutos;  // Diesem Auto zuweisen
    }
    
    public static int getAnzahlAutos() {
        return anzahlAutos;
    }
}

Auto auto1 = new Auto("Rot", 150);    // anzahlAutos = 1
Auto auto2 = new Auto("Blau", 200);   // anzahlAutos = 2
Auto auto3 = new Auto("Grün", 180);   // anzahlAutos = 3

System.out.println(Auto.getAnzahlAutos());  // 3
//                 ↑ Klassenname, nicht Objekt!

Abbildung 1: Instanzvariablen existieren pro Objekt. Static-Variablen existieren nur EINMAL für die gesamte Klasse.

Static Variablen (Klassenvariablen)

Eigenschaften:

• Gehören zur Klasse, nicht zu einzelnen Objekten
• Existieren nur einmal im Speicher
• Werden von allen Objekten geteilt
• Können ohne Objekt aufgerufen werden: Klasse.variable

public class Konfiguration {
    // Static Variablen
    public static String appName = "MeineApp";
    public static int maxUsers = 100;
    public static boolean debugMode = false;
}

// Zugriff OHNE Objekt:
System.out.println(Konfiguration.appName);  // MeineApp
Konfiguration.debugMode = true;  // Ändern

Static Methoden (Klassenmethoden)

Static Methoden gehören ebenfalls zur Klasse:

public class Mathe {
    public static int addiere(int a, int b) {
        return a + b;
    }
    
    public static int multipliziere(int a, int b) {
        return a * b;
    }
    
    public static double quadratwurzel(double x) {
        return Math.sqrt(x);  // Math.sqrt ist auch static!
    }
}

// Aufruf OHNE Objekt:
int summe = Mathe.addiere(5, 3);        // 8
int produkt = Mathe.multipliziere(4, 7); // 28

Abbildung 2: Static Methoden brauchen kein Objekt. Instanzmethoden brauchen ein Objekt und können auf this zugreifen.

Die wichtigste Regel für Static Methoden

Static Methoden können NICHT auf Instanzvariablen oder this zugreifen!

public class Auto {
    private String farbe;  // Instanzvariable
    private static int anzahl = 0;  // Klassenvariable
    
    // ❌ FEHLER!
    public static void test() {
        System.out.println(this.farbe);  // "non-static variable cannot be referenced"
        System.out.println(farbe);       // Gleicher Fehler!
    }
    
    // ✅ OK: Static Methode greift auf static Variable zu
    public static int getAnzahl() {
        return anzahl;  // OK!
    }
    
    // ✅ OK: Instanzmethode kann auf alles zugreifen
    public void info() {
        System.out.println(farbe);   // OK (Instanzvariable)
        System.out.println(anzahl);  // OK (Klassenvariable)
    }
}

Merke:

• Static → Static: ✅
• Instanz → Static: ✅
• Instanz → Instanz: ✅
• Static → Instanz: ❌

final — Unveränderliche Werte

final bedeutet: Kann nach der Initialisierung nicht mehr geändert werden.

public class Person {
    private final String geburtsdatum;  // Muss im Konstruktor gesetzt werden!
    private String name;
    
    public Person(String geburtsdatum, String name) {
        this.geburtsdatum = geburtsdatum;  // ✅ OK im Konstruktor
        this.name = name;
    }
    
    public void aendern() {
        this.name = "Neuer Name";  // ✅ OK (nicht final)
        // this.geburtsdatum = "2000-01-01";  // ❌ FEHLER! final!
    }
}

static final — Echte Konstanten

Die Kombination static final ergibt eine echte Konstante:

public class GameSettings {
    // Echte Konstanten: static + final + GROSSBUCHSTABEN
    public static final int MAX_PLAYERS = 4;
    public static final int MIN_LEVEL = 1;
    public static final int MAX_LEVEL = 100;
    public static final double GRAVITY = 9.81;
    public static final String VERSION = "1.0.0";
}

// Zugriff:
if (level > GameSettings.MAX_LEVEL) {
    level = GameSettings.MAX_LEVEL;
}

Abbildung 3: static final Konstanten werden in SCREAMING_SNAKE_CASE geschrieben.

Die Namenskonvention:

• Konstanten: SCREAMING_SNAKE_CASE (Großbuchstaben, Unterstriche)
• Beispiele: MAX_VALUE, DEFAULT_TIMEOUT, PI

Bekannte static-Beispiele aus Java

Du hast static schon oft benutzt, ohne es zu wissen:

// Math-Klasse (alles static!)
double wurzel = Math.sqrt(16);      // 4.0
double maximum = Math.max(5, 10);   // 10
double pi = Math.PI;                // 3.14159...

// System-Klasse
System.out.println("Hello");        // out ist static!
long zeit = System.currentTimeMillis();

// Integer-Klasse
int zahl = Integer.parseInt("42");  // Static Methode
int max = Integer.MAX_VALUE;        // Static Konstante

// Arrays-Klasse
int[] arr = {3, 1, 4, 1, 5};
Arrays.sort(arr);                   // Static Methode

Wann static und wann nicht?

Verwende static für…	Verwende KEIN static für…
Zähler für alle Objekte	Objektspezifische Daten
Utility-Methoden (Math, Parse)	Methoden, die this brauchen
Konstanten	Attribute, die pro Objekt variieren
Factory-Methoden	Normale Getter/Setter
Konfigurationswerte	Objektzustand

Faustregel: Wenn etwas ohne Objekt funktionieren soll → static. Wenn es zu einem spezifischen Objekt gehört → kein static.

---

🟡 PROFESSIONALS

Schon OOP-Erfahrung aus C#, C++, PHP? Hier sind die Java-Besonderheiten.

Für C#-Umsteiger: Gleiche Konzepte, kleine Unterschiede

C# und Java sind hier sehr ähnlich:

// C#
public class Counter {
    public static int Count { get; private set; }
    public const int MAX = 100;  // const statt static final
}

// Java
public class Counter {
    private static int count;
    public static final int MAX = 100;  // static final statt const
    
    public static int getCount() { return count; }
}

Unterschiede:

• C# hat const (Compile-Zeit-Konstante), Java nur static final
• C# Properties vs. Java Getter/Setter

Für C++-Umsteiger: Keine separate Definition

In C++ musst du static-Variablen außerhalb der Klasse definieren:

// C++
class Auto {
    static int anzahl;  // Deklaration
};
int Auto::anzahl = 0;   // Definition (separat!)

// Java — alles in einem
public class Auto {
    private static int anzahl = 0;  // Deklaration UND Definition
}

Für PHP-Umsteiger: Kein self:: nötig

// PHP
class Auto {
    private static $anzahl = 0;
    
    public static function getAnzahl() {
        return self::$anzahl;  // self:: für static
    }
}

// Java
public class Auto {
    private static int anzahl = 0;
    
    public static int getAnzahl() {
        return anzahl;  // Kein Prefix nötig (innerhalb der Klasse)
    }
}
// Von außen: Auto.anzahl oder Auto.getAnzahl()

Static Import — Für kürzeren Code

Mit import static kannst du static-Member direkt importieren:

// Ohne static import:
double x = Math.sqrt(Math.pow(3, 2) + Math.pow(4, 2));

// Mit static import:
import static java.lang.Math.*;

double x = sqrt(pow(3, 2) + pow(4, 2));  // Kürzer!

Vorsicht: Kann die Lesbarkeit verschlechtern, wenn nicht klar ist, woher die Methode kommt.

Lombok: Utility-Klassen einfach erstellen

import lombok.experimental.UtilityClass;

@UtilityClass  // Macht Klasse final, Konstruktor private
public class StringUtils {
    public String capitalize(String s) {  // Automatisch static!
        return s.substring(0, 1).toUpperCase() + s.substring(1);
    }
}

---

🔵 BONUS

Für Wissbegierige: Static Initializer, Singleton, Thread-Safety.

Static Initializer Block

Code, der beim Laden der Klasse ausgeführt wird:

public class Datenbank {
    private static Connection connection;
    
    // Static Initializer — wird einmal beim Klassenladen ausgeführt
    static {
        System.out.println("Initialisiere Datenbankverbindung...");
        try {
            connection = DriverManager.getConnection("jdbc:...");
        } catch (SQLException e) {
            throw new RuntimeException("DB-Verbindung fehlgeschlagen!", e);
        }
    }
    
    public static Connection getConnection() {
        return connection;
    }
}

Singleton-Pattern mit static

Nur eine einzige Instanz einer Klasse:

public class Logger {
    // Die einzige Instanz
    private static Logger instance;
    
    // Privater Konstruktor — niemand kann new Logger() aufrufen
    private Logger() { }
    
    // Zugriffsmethode
    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
    
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

// Verwendung:
Logger.getInstance().log("App gestartet");
Logger.getInstance().log("Alles OK");  // Gleiche Instanz!

Hinweis: In echten Anwendungen ist das Singleton-Pattern oft problematisch (Testing, Thread-Safety). Modernes Java bevorzugt Dependency Injection.

Utility-Klassen richtig bauen

Eine Klasse nur mit static-Methoden:

public final class StringUtils {  // final = keine Vererbung
    
    // Privater Konstruktor = keine Instanzen
    private StringUtils() {
        throw new AssertionError("Keine Instanzen erlaubt!");
    }
    
    public static boolean isEmpty(String s) {
        return s == null || s.isEmpty();
    }
    
    public static String reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }
    
    public static String repeat(String s, int times) {
        return s.repeat(times);
    }
}

---

💬 Real Talk

Tom fragt, Nova erklärt — Die Fragen, die sich jeder stellt.

Java Fleet Meetingraum, 10:30 Uhr. Tom hat sein Notizbuch dabei, Nova erklärt am Whiteboard.

---

Tom: Nova, ich versteh nicht, warum ich static brauche. Kann ich nicht einfach ein globales Objekt erstellen?

Nova: zeichnet Könntest du. Aber dann müsstest du dieses Objekt überall herumreichen. Mit static ist der Wert einfach DA — ohne Objekt.

Tom: Aber ist das nicht wie globale Variablen? Die sind doch böse?

Nova: lacht Guter Punkt! Ja, übermäßiger static-Einsatz ist problematisch. Aber für Konstanten und Utility-Methoden ist es perfekt. Math.sqrt() braucht kein Objekt — das ist reine Berechnung.

Tom: Okay… und wann weiß ich, dass ich static NICHT verwenden soll?

Nova: Frag dich: „Braucht dieser Wert Zugriff auf das spezifische Objekt?“ Wenn ja → kein static. Wenn nein → vielleicht static. Zum Beispiel: Die Farbe eines Autos ist objektspezifisch. Ein Zähler für ALLE Autos ist klassenspezifisch.

Tom: Und final? Ist das wie const in anderen Sprachen?

Nova: Fast. final heißt: einmal gesetzt, nie wieder geändert. Bei Primitiven ist das einfach. Bei Objekten bedeutet es: Die Referenz ist fix, aber der Inhalt kann sich ändern!

Tom: Häh?

Nova: schreibt

final List<String> liste = new ArrayList<>();
liste.add("A");  // ✅ OK! Inhalt ändern
liste = new ArrayList<>();  // ❌ FEHLER! Referenz ändern

Tom: Oh! Das ist tricky…

Nova: Ja. Deshalb für echte Unveränderlichkeit: Collections.unmodifiableList() oder Records verwenden.

---

✅ Checkpoint: Hast du es verstanden?

Quiz

Frage 1: Was bedeutet static bei einer Variable?

Frage 2: Können static-Methoden auf this zugreifen? Warum (nicht)?

Frage 3: Was ist der Unterschied zwischen final und static final?

Frage 4: Wie heißt die Namenskonvention für Konstanten?

Frage 5: Du siehst diesen Code:

public class Auto {
    private String farbe;
    
    public static void printFarbe() {
        System.out.println(farbe);
    }
}

Was ist das Problem?

---

Mini-Challenge

Aufgabe: Erstelle eine Konto-Klasse mit Static-Elementen:

1. Static Konstanten:
   • MINDEST_EINLAGE = 100.0
   • MAX_TAGESABHEBUNG = 1000.0
   • IBAN_PREFIX = "DE"
2. Static Variable:
   • anzahlKonten — zählt alle erstellten Konten
3. Static Methode:
   • getAnzahlKonten() — gibt die Anzahl zurück
   • generiereIBAN() — generiert eine eindeutige IBAN (IBAN_PREFIX + anzahlKonten)
4. Instanzvariablen:
   • iban (final) — wird per generiereIBAN() gesetzt
   • kontostand

Lösung: Findest du am Anfang von Tag 6! 🚀

---

❓ FAQ — Häufig gestellte Fragen

Frage 1: Kann ich static-Variablen im Konstruktor initialisieren?

Ja, aber es ist ungewöhnlich. Besser: Direkt bei der Deklaration oder im static-Block.

private static int counter;

static {
    counter = loadFromDatabase();  // Komplexe Initialisierung
}

---

Frage 2: Was passiert mit static-Variablen bei Programmende?

Sie werden beim Entladen der Klasse freigegeben. In normalen Programmen: beim Programmende. In Servern: komplizierter (ClassLoader-Thema).

---

Frage 3: Kann ich static-Methoden überschreiben?

Nein! Static-Methoden werden nicht vererbt im polymorphen Sinne. Sie werden „versteckt“ (hidden), nicht überschrieben (overridden).

---

Frage 4: Warum ist main() static?

Weil Java einen Einstiegspunkt braucht, bevor irgendein Objekt existiert. static erlaubt den Aufruf ohne vorheriges new.

---

Frage 5: Sind static-Variablen thread-safe?

Nein! Wenn mehrere Threads auf dieselbe static-Variable zugreifen, brauchst du Synchronisation. Für Thread-Safety: volatile, synchronized, oder AtomicInteger etc.

---

Frage 6: Wann Enum statt static final?

Wenn du eine feste Menge von Werten hast (z.B. Wochentage, Status-Codes), ist enum besser als viele static final Konstanten.

// ❌ Weniger gut:
public static final int STATUS_AKTIV = 1;
public static final int STATUS_INAKTIV = 2;

// ✅ Besser:
public enum Status { AKTIV, INAKTIV }

---

Frage 7: Bernd meinte, Utility-Klassen mit nur static-Methoden seien „prozedurales Denken in OOP-Kleidung“. Hat er recht?

schmunzelt Typisch Bernd. Er hat einen Punkt — übermäßige Utility-Klassen können ein Zeichen sein, dass Logik in die falschen Klassen wandert. ABER: Math, Arrays, Collections sind alle Utility-Klassen, und niemand beschwert sich.

Real talk: Utility-Klassen sind OK für stateless Operationen. Wenn sie wachsen und wachsen, solltest du nachdenken, ob die Logik nicht besser zu einer richtigen Klasse gehört. Balance ist key. 🤷

---

📚 Quiz-Lösungen

Frage 1: Was bedeutet static bei einer Variable?

Antwort:

Eine static-Variable gehört zur Klasse, nicht zu einzelnen Objekten. Sie existiert nur einmal im Speicher und wird von allen Objekten geteilt.

---

Frage 2: Können static-Methoden auf this zugreifen?

Antwort:

Nein! Static-Methoden haben keinen Zugriff auf this, weil sie ohne Objekt aufgerufen werden können. Es gibt kein „aktuelles Objekt“, auf das this zeigen könnte.

---

Frage 3: Was ist der Unterschied zwischen final und static final?

Antwort:

• final: Der Wert kann nach Initialisierung nicht geändert werden. Jedes Objekt hat seine eigene Kopie.
• static final: Zusätzlich gehört der Wert zur Klasse (nur eine Kopie) — eine echte Konstante.

---

Frage 4: Wie heißt die Namenskonvention für Konstanten?

Antwort:

SCREAMING_SNAKE_CASE — Großbuchstaben mit Unterstrichen.

Beispiele: MAX_VALUE, DEFAULT_TIMEOUT, PI

---

Frage 5: Was ist das Problem?

public class Auto {
    private String farbe;
    
    public static void printFarbe() {
        System.out.println(farbe);  // ❌ FEHLER!
    }
}

Antwort:

Die static-Methode printFarbe() versucht, auf die Instanzvariable farbe zuzugreifen. Das ist nicht erlaubt, weil static-Methoden kein this haben und daher keine Instanzvariablen kennen.

Fehlermeldung: „non-static variable farbe cannot be referenced from a static context“

Lösung: Entweder farbe auch static machen (falls sinnvoll) oder die Methode nicht-static machen.

---

🎉 Tag 5 geschafft!

Du hast die KOPFNUSS geknackt! 🥜🔨

Das hast du heute gelernt:

• ✅ static für Klassenvariablen und -methoden
• ✅ final für unveränderliche Werte
• ✅ static final für echte Konstanten
• ✅ Die Einschränkungen von static (kein this, keine Instanzvariablen)

Das war anspruchsvoll — gönn dir eine Pause! 💪

---

🔮 Wie geht’s weiter?

Morgen in Tag 6: Vererbung — Grundlagen

Das wird richtig spannend! Du lernst:

• extends — eine Klasse von einer anderen ableiten
• Was wird vererbt, was nicht?
• super — auf die Elternklasse zugreifen
• Wann Vererbung sinnvoll ist (und wann nicht)

Das ist ein Kernkonzept von OOP! 🎯

---

📦 Downloads

Starter-Projekt für Tag 5:

⬇️ Tag05_Static_Konstanten.zip — Komplettes Maven-Projekt

Inhalt:

Tag05_Static_Konstanten/
├── pom.xml
├── README.md
└── src/main/java/
    └── de/javafleet/oop/
        ├── Main.java
        ├── model/
        │   ├── Auto.java           (mit static Zähler)
        │   └── Mitarbeiter.java    (Lösung Tag 4)
        └── util/
            ├── MathUtils.java      (Utility-Klasse)
            └── GameSettings.java   (Konstanten)

---

🔧 Troubleshooting

Problem: „non-static variable cannot be referenced from a static context“

error: non-static variable farbe cannot be referenced from a static context

Lösung: Du versuchst, von einer static-Methode auf eine Instanzvariable zuzugreifen. Entweder:

• Die Variable auch static machen
• Die Methode nicht-static machen
• Ein Objekt übergeben und darüber zugreifen

---

Problem: „cannot assign a value to final variable“

error: cannot assign a value to final variable PI

Lösung: final-Variablen können nach der Initialisierung nicht geändert werden. Das ist beabsichtigt!

---

Problem: Static-Variable ist zwischen Tests nicht zurückgesetzt

In Unit-Tests können static-Variablen zwischen Tests überleben. Lösung: Reset-Methode oder @BeforeEach verwenden.

---

🔗 Resources & Links

🟢 Für Einsteiger

Ressource	Beschreibung	Sprache
Oracle — Static Members	Offizielle Doku	🇬🇧
W3Schools — Java Static	Einfache Erklärungen	🇬🇧

🟡 Für Fortgeschrittene

Ressource	Beschreibung	Sprache
Baeldung — Static in Java	Tiefgehende Erklärung	🇬🇧
Effective Java — Item 4	Utility-Klassen	🇬🇧

---

👋 Bis morgen!

Tag 5 ist durch — du hast die erste KOPFNUSS geknackt! 🥜

Morgen: Vererbung — das Herzstück von OOP.

Mach jetzt erstmal Pause. Du hast es dir verdient! 🚀

---

Nova Trent
Junior Entwicklerin bei Java Fleet Systems Consulting
„Static gehört zur Klasse. Das hat endlich klick gemacht!“ 💡

---

Tags: #Java #OOP #Static #Final #Konstanten #Tutorial

© 2025 Java Fleet Systems Consulting | java-developer.online