Alle Artikel
Liskov Substitution Principle: Vererbung richtig einsetzen in Java
Das Liskov Substitution Principle verhindert fehlerhafte Vererbungshierarchien – lerne es mit konkreten Java-Beispielen korrekt anzuwenden.
Abstrakte Klassen als reine Datencontainer — warum das nach hinten losgeht
Viele Einsteiger missbrauchen abstrakte Klassen als Datenbehälter ohne Verhalten — warum das ein Fehler ist und wie du es besser machst.
DRY-Prinzip in Java: Warum doppelter Code dich langsam macht
Das DRY-Prinzip zeigt dir, wie du doppelten Java-Code in wiederverwendbare Methoden verwandelst und Fehler langfristig vermeidest.
Public vs. Private in Java: Kapselung richtig verstehen und anwenden
Was ist der Unterschied zwischen public und private in Java – und warum ist Kapselung mehr als nur ein Zugriffsmodifikator?
Abstrakte Klasse vs. Interface: Eine Architekturentscheidung unter Druck
Anhand eines Payment-Systems zeigen wir, wann abstrakte Klassen und wann Interfaces die richtige Wahl sind — mit Code und klaren Kriterien.
Java Access Modifiers im Interview: private, protected, public erklärt
Lerne, wie private, protected, public und package-private in Java funktionieren – mit Musterantworten für dein nächstes Interview.
Aggregation vs. Komposition: Wenn du alles als Komposition modellierst
Warum blindes Kompositions-Denken in Java zu versteckten Lebenszyklusbugs führt – und wann Aggregation die ehrlichere Wahl ist.
Compile-time vs. Runtime-Polymorphismus: Wann entscheidet Java wirklich?
Java löst Methodenaufrufe zu zwei verschiedenen Zeitpunkten auf – wer den Unterschied kennt, vermeidet schwer findbare Bugs.
Interface Default Methods vs. abstrakte Klassen: Wann nimmst du was?
Default Methods in Interfaces und abstrakte Klassen lösen ähnliche Probleme – aber mit unterschiedlichen Konsequenzen für dein Design.
Einfach- vs. Mehrfachvererbung in Java: Warum Interfaces die bessere Wahl sind
Warum Java keine Mehrfachvererbung kennt und wie Interfaces dasselbe Problem sauberer lösen – erklärt anhand einer echten Fallstudie.
Method Overloading in Java: Interview-Fragen und Antworten
Method Overloading erklärt: Was Interviewer wirklich fragen, welche Fallstricke es gibt und wie du souverän antwortest.
Functional Interfaces falsch eingesetzt: Warum eigene @FunctionalInterface oft ein Anti-Pattern ist
Eigene Functional Interfaces statt JDK-Standardtypen zu definieren erzeugt unnötige Komplexität – lerne wann und warum das ein Fehler ist.
Interfaces in Java: Warum du konkrete Klassen nicht direkt verdrahten solltest
Lerne, wie du mit Java-Interfaces flexiblen Code schreibst und typische Abhängigkeitsfallen von Anfang an vermeidest.
Method Overriding vs. Method Hiding in Java – Was ist der Unterschied?
Method Overriding und Method Hiding sehen ähnlich aus, verhalten sich aber grundlegend anders – dieser Artikel erklärt den entscheidenden Unterschied.
Java-Konstruktoren: Default, Parameterized und Copy Constructor erklärt
Lerne, wie Default-, parametrisierte und Copy-Konstruktoren in Java funktionieren – mit Codebeispielen, Stolperfallen und Interview-Fragen.
Java Vererbung im Interview: Die 9 häufigsten Fragen mit Musterantworten
Vererbung in Java sicher erklären: Lerne die 9 typischen Interview-Fragen mit Musterantworten, Follow-ups und häufigen Fehlern.
Alles in eine Klasse: Warum der God-Class-Ansatz dein Projekt zerstört
Warum eine einzige Klasse für alles verantwortlich zu machen ein klassisches Anti-Pattern ist – und wie du es in Java besser löst.
Constructor Chaining in Java: Konstruktoren sauber wiederverwenden
Mit Constructor Chaining vermeidest du duplizierten Initialisierungscode und hältst deine Java-Klassen wartbar und konsistent.
this vs super in Java: Wann du welches Keyword brauchst
this und super sind beide Referenzen in Java-Klassen – aber auf ganz verschiedene Objekte. Hier lernst du den Unterschied mit echten Beispielen.
JDK vs. JRE vs. JVM: Was du wirklich installieren musst und warum
JDK, JRE und JVM sind nicht dasselbe – wer den Unterschied kennt, vermeidet Deployment-Fehler und versteht wie Java wirklich funktioniert.
JVM-Architektur tief verstehen: Bytecode, Class Loading und JIT-Compiler
Die JVM ist mehr als eine Laufzeitumgebung — sie ist ein komplexes System aus Bytecode-Interpreter, Class Loader und JIT-Compiler. Wer versteht, wie diese Schichten zusammenarbeiten, schreibt besseren Code und löst Performance-Probleme gezielter.
Java Module System (JPMS): Starke Kapselung und saubere Abhängigkeiten ab Java 9
Das Java Platform Module System (JPMS) löst das seit Jahren bekannte Classpath-Chaos und erzwingt echte Kapselung auf Package-Ebene. Du lernst, wie Module definiert werden, wie Abhängigkeiten deklariert werden und wann der Einsatz von JPMS sinnvoll ist.
Java Reflection API: Laufzeit-Introspektion meistern
Die Reflection API erlaubt es dir, Klassen, Methoden und Felder zur Laufzeit zu inspizieren und zu manipulieren – ohne diese zum Compile-Zeitpunkt zu kennen. Du lernst, wann Reflection sinnvoll ist, welche Performance-Fallen dich erwarten und wie Frameworks wie Spring und Hibernate sie intern nutzen.
Java ClassLoader-Hierarchie: Wie die JVM Klassen lädt und warum das wichtig ist
Der ClassLoader-Mechanismus bestimmt, wie und woher Java Klassen lädt – und ist die Grundlage für Frameworks, Plugins und dynamisches Nachladen von Code. Du lernst den Delegation-Mechanismus, die drei Standard-ClassLoader und typische Fallstricke wie ClassCastException und ClassNotFoundException.
Memory Leaks in Java: Erkennen, Verstehen und Vermeiden
Java hat einen Garbage Collector – aber der schützt dich nicht automatisch vor Memory Leaks. Du lernst, wie Lecks entstehen, wie du sie mit Tools aufspürst und welche Muster du aktiv vermeiden musst.
Java Garbage Collector Typen: G1, ZGC und Shenandoah im Vergleich
G1, ZGC, Shenandoah — drei moderne Garbage Collectors, drei unterschiedliche Philosophien. Du lernst, wie sie intern funktionieren, welche Pausenzeiten du erwarten kannst und wann du welchen GC für deine Anwendung wählst.
Java Garbage Collection: Wie die JVM Speicher verwaltet und warum du das verstehen musst
Die Garbage Collection befreit dich von manueller Speicherverwaltung – aber sie ist kein Freifahrtschein für sorglosen Code. Du lernst, wie die JVM Objekte erkennt, die nicht mehr gebraucht werden, welche Algorithmen dabei zum Einsatz kommen, und welche Fehler selbst erfahrene Entwickler dabei machen.
Stack vs. Heap Memory in Java: Was wirklich passiert wenn du ein Objekt erstellst
Stack und Heap sind die zwei zentralen Speicherbereiche in der JVM – und wer nicht versteht, was dort passiert, schreibt unwissentlich ineffizienten oder fehlerhaften Code. Dieser Artikel erklärt den Unterschied, wie Java Variablen und Objekte verwaltet, und warum das für Performance und Fehlersuche direkt relevant ist.
Pass-by-Value vs. Pass-by-Reference in Java: Was wirklich passiert
Java übergibt Argumente immer als Wert — aber was bedeutet das bei Objekten? Dieser Artikel erklärt den Unterschied zwischen Wert- und Referenzübergabe, zeigt typische Denkfehler und warum du dieses Konzept für jedes Java-Interview kennen musst.
Das volatile Keyword in Java: Sichtbarkeit, Happens-Before und die Grenzen der Atomarität
volatile löst ein spezifisches Problem in der Nebenläufigkeit: die Sichtbarkeit von Variablen zwischen Threads. Dieser Artikel zeigt, wann volatile ausreicht, wann es gefährlich wenig ist — und warum viele Entwickler es falsch verstehen.
Das transient Keyword in Java: Serialisierung gezielt steuern
Das transient Keyword steuert, welche Felder beim Serialisieren eines Objekts ignoriert werden. Du lernst, wann und warum du es einsetzt – und welche typischen Fehler dabei passieren.
Das final-Keyword in Java: Variablen, Methoden und Klassen richtig einsetzen
Das final-Keyword gehört zu den meistgenutzten und gleichzeitig meistmissverstandenen Konzepten in Java. Du lernst, was final in drei verschiedenen Kontexten bedeutet, welche häufigen Fehler dabei entstehen und wann du es gezielt einsetzen solltest.
Static Imports in Java: Weniger Tipp-Arbeit, mehr Klarheit
Static Imports erlauben es dir, statische Methoden und Konstanten direkt ohne Klassennamen zu verwenden. Du lernst, wann das deinen Code lesbarer macht – und wann es ihn ruiniert.
Java Text Blocks: Mehrzeilige Strings ohne Escape-Chaos
Text Blocks lösen ein altbekanntes Problem in Java: mehrzeilige Strings lesbar zu schreiben, ohne sich durch Escape-Sequenzen zu kämpfen. Du lernst die Syntax, die Einrückungslogik und typische Fallstricke.
var in Java: Local Variable Type Inference verstehen und richtig einsetzen
Seit Java 10 kannst du lokale Variablen mit var deklarieren, ohne den Typ explizit zu schreiben. Der Artikel zeigt, wie der Compiler den Typ ableitet, wo var sinnvoll ist – und wo es deinen Code unleserlich macht.
Java Records: Unveränderliche Datenhüllen ohne Boilerplate
Records lösen ein klassisches Java-Problem: viel Code für wenig Nutzen bei Datenhaltungsklassen. Du lernst, wie Records funktionieren, wo sie sinnvoll sind und welche Fallstricke dich erwarten.
Sealed Classes in Java: Vererbung kontrolliert einsetzen
Sealed Classes erlauben dir, die Vererbungshierarchie explizit zu begrenzen — und damit sicherere, ausdrucksstärkere APIs zu bauen. Du lernst, wie sie funktionieren, wann sie sinnvoll sind, und warum sie perfekt mit Pattern Matching zusammenspielen.
Pattern Matching in Java: instanceof und switch endlich richtig verstehen
Pattern Matching vereinfacht typische Cast-Operationen und switch-Ausdrücke drastisch. Du lernst, wie instanceof und switch expressions seit Java 16 bzw. 21 zusammenspielen — und welche Fallstricke dabei lauern.
Switch Expressions in Java 14+: Moderner Ersatz für fehleranfällige Switch-Statements
Switch Expressions lösen die klassischen Probleme des alten switch-Statements: kein vergessenes break, kein Fall-Through-Chaos, und der Switch gibt jetzt direkt einen Wert zurück. Du lernst die neue Syntax, die wichtigsten Unterschiede und wann du welche Variante einsetzen solltest.
Der Ternary Operator in Java: Kompakt, aber mit Tücken
Der ternary Operator ist Javas einziger dreistelliger Operator und erlaubt dir, einfache if-else-Konstrukte in einer Zeile auszudrücken. Du lernst, wann er Code lesbarer macht – und wann er ihn ruiniert.
Operatoren und Operatorenpriorität in Java
Operatoren sind die Grundbausteine jedes Java-Programms – aber falsche Erwartungen an ihre Auswertungsreihenfolge führen zu subtilen Bugs. Dieser Artikel erklärt alle wichtigen Operatortypen und zeigt, warum Operatorenpriorität kein Detail ist, das man ignorieren kann.
Java Annotations: Built-in und Custom Annotations verstehen und einsetzen
Annotations sind mehr als nur Kommentare für den Compiler — sie steuern Frameworks, generieren Code und dokumentieren Absichten. Du lernst, wie Built-in Annotations funktionieren, wie du eigene schreibst und wann das sinnvoll ist.
Java Enums: Konstanten richtig modellieren
Enums sind mehr als nur benannte Konstanten — sie sind vollwertige Java-Typen mit Methoden, Feldern und Verhalten. Dieser Artikel zeigt dir, wie Enums funktionieren, wo sie Sinn machen und welche Fallstricke dich erwarten.
Varargs in Java: Variable Argumentlisten richtig einsetzen
Varargs erlauben Methoden, eine beliebige Anzahl von Argumenten desselben Typs entgegenzunehmen. Du lernst, wie Varargs intern funktionieren, welche Fallstricke beim Einsatz lauern und wann du sie besser vermeidest.
Arrays vs. ArrayList in Java: Wann du welche Datenstruktur brauchst
Arrays und ArrayLists wirken auf den ersten Blick ähnlich — aber sie funktionieren grundlegend anders. Du lernst die Unterschiede, typische Fallstricke und bekommst eine klare Entscheidungshilfe für die Praxis.
StringBuilder vs. StringBuffer: Was du wirklich wissen musst
StringBuilder und StringBuffer lösen dasselbe Problem — unveränderliche Strings effizient zu manipulieren. Dieser Artikel zeigt dir den entscheidenden Unterschied, warum StringBuffer fast ausgestorben ist, und wann du welche Klasse einsetzt.
String Pool & String Immutability in Java verstehen
Strings in Java verhalten sich anders als andere Objekte – wegen des String Pools und ihrer Unveränderlichkeit. Dieser Artikel erklärt, wie der JVM-interne String Pool funktioniert, warum Strings immutable sind und welche Fallen dabei lauern.
Type Casting in Java: Implicit und Explicit erklärt
Type Casting bestimmt, wie Java Werte zwischen verschiedenen Datentypen konvertiert. Du lernst den Unterschied zwischen automatischer und manueller Umwandlung, wann der Compiler eingreift und wann du selbst handeln musst.
Autoboxing und Unboxing in Java: Primitives und Wrapper-Typen verstehen
Java konvertiert automatisch zwischen primitiven Typen und ihren Wrapper-Klassen – das klingt praktisch, hat aber versteckte Tücken. Du lernst, wie Autoboxing und Unboxing funktionieren, wo Performance-Probleme entstehen und warum ein scheinbar harmloser Vergleich zu einem Bug werden kann.
Primitive Datentypen vs. Referenztypen in Java
Java kennt zwei grundlegend verschiedene Arten von Variablen: Primitive und Referenztypen. Wer den Unterschied nicht versteht, baut Bugs, die schwer zu finden sind — besonders beim Vergleichen von Werten.