Java

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

---

Weblink

• Tim Buchalka Java Masterclass 2025
• Christian Ullenboom Der moderne Java-Kurs
• Denis Panjuta 60 Days of Java

Spring boot

• Chad Darby: „Spring Boot 4, Spring 7 & Hibernate for Beginners“.
• in28Minutes (Ranga Karanam): „ Master Spring Boot 3 & Spring Framework 6 with Java
• Navin Reddy (Telusko): „Java Spring Framework, Spring Boot, Spring AI - Gen AI
• Christian Ullenboom: „Spring Boot 3 & Spring Framework 6: GRUNDLAGEN“.
• [NEW] Spring Boot 4, Spring Framework 7: Beginner to Guru

Dieser Plan bietet eine strukturierte Herangehensweise, um Java von den Grundlagen bis hin zu fortgeschrittenen Themen und Frameworks zu meistern. Er teilt das Lernen in verschiedene Phasen mit geschätztem Zeitaufwand auf.

Phase 1: Grundlagen der Java-Programmierung

Dauer: ca. 2-3 Wochen Ziel: Die Basis-Konzepte der Programmierung und die Syntax von Java verstehen.

• Woche 1: Einführung und Basis-Syntax
  • Installation des JDKs (Java Development Kit) und einer IDE (IntelliJ IDEA, Eclipse oder VS Code).
  • Verstehen des Konzepts: Code schreiben, kompilieren (`javac`) und ausführen (`java`).
  • Datentypen (primitiv vs. Referenz), Variablen und Konstanten.
  • Operatoren (arithmetisch, relational, logisch).
  • Kontrollstrukturen: Verzweigungen (`if`, `else`, `switch`).
  • Schleifen (`for`, `while`, `do-while`).

• Woche 2-3: Arrays, Strings und erste Methoden
  • Definition, Initialisierung und Iteration über eindimensionale und mehrdimensionale Arrays.
  • Die `String`-Klasse und grundlegende String-Manipulationen.
  • Methoden definieren, Parameterübergabe, Rückgabetypen.
  • Lokaler Scope vs. globaler Scope.

Phase 2: Objektorientierte Programmierung (OOP)

Dauer: ca. 3-4 Wochen Ziel: In Objekten denken lernen und die vier Kernprinzipien der OOP anwenden.

• Kernkonzepte:
  • Klassen und Objekte erstellen.
  • Konstruktoren und das Schlüsselwort `this`.
  • Kapselung (Encapsulation): Getter, Setter und Zugriffsmodifikatoren (`public`, `private`, `protected`).
  • Vererbung (Inheritance): Schlüsselwörter `extends` und `super`.
  • Polymorphie (Polymorphism): Methoden überladen (Overloading) und überschreiben (Overriding).
  • Abstraktion: Abstrakte Klassen und das Schlüsselwort `abstract`.
  • Interfaces: Definition, Implementierung (`implements`) und Default-Methoden.

Phase 3: Fortgeschrittene Kernkonzepte (Core Java)

Dauer: ca. 4 Wochen Ziel: Robusten, sicheren und effizienten Code schreiben und Standardbibliotheken nutzen.

• Woche 1: Exception Handling und Enums
  • Checked vs. Unchecked Exceptions, `Error`.
  • `try`, `catch`, `finally`, `throw` und `throws`.
  • Eigene Exception-Klassen schreiben (Custom Exceptions).
  • Enums (Aufzählungstypen).

• Woche 2: Generics und Java Collections Framework
  • Arbeiten mit Generics zur Typensicherheit.
  • Listen: `ArrayList`, `LinkedList`.
  • Sets: `HashSet`, `TreeSet`.
  • Maps: `HashMap`, `TreeMap`.
  • Iteratoren und die `for-each`-Schleife.

• Woche 3: Dateiverarbeitung (File I/O)
  • Lesen und Schreiben von Textdateien (`FileReader`, `FileWriter`, `BufferedReader`, `BufferedWriter`).
  • Einführung in die NIO.2 API (Klassen `Path`, `Paths`, `Files`).
  • Serialisierung von Objekten.

• Woche 4: Moderne Java-Features (ab Java 8)
  • Lambda-Ausdrücke und Funktionale Interfaces (z.B. `Predicate`, `Function`, `Consumer`, `Supplier`).
  • Die Stream API zum Filtern, Mappen und Reduzieren von Collections.
  • Das `Optional`-Konstrukt zur Vermeidung von `NullPointerException`s proaktiv einsetzen.
  • Die Date/Time API (`java.time`).

Phase 4: Architektur, Tools und Werkzeuge

Dauer: ca. 2-3 Wochen Ziel: Professionelle Software-Entwicklung in Java erlernen.

• Build-Tools und Abhängigkeitsverwaltung:
  • Einführung in Maven und/oder Gradle (`pom.xml` bzw. `build.gradle`).
  • Verstehen des Build-Lifecycles (Compile, Test, Package).

• Testen (TDD - Test Driven Development):
  • Unit-Tests schreiben mit JUnit 5.
  • Mocking von Abhängigkeiten mit Mockito.

• Versionskontrolle:
  • Grundlagen und Best Practices in Git und GitHub/GitLab.

Phase 5: Nebenläufigkeit (Concurrency)

Dauer: ca. 2 Wochen Ziel: Programme schreiben, die mehrere Aufgaben parallel und sicher ausführen.

• Grundlagen:
  • Der Lifecycle von Threads.
  • Erstellen von Threads (`Thread`-Klasse vs. `Runnable`-Interface).
  • Synchronisation, Race Conditions, Deadlocks vermeiden.
  • Das Schlüsselwort `volatile` und atomare Datentypen.

• Fortgeschrittene Konzepte (Concurrency Utilities):
  • Executor Framework und Thread-Pools.
  • `Callable` und `Future`.
  • `ForkJoinPool` und parallele Streams.

Phase 6: Frameworks und Enterprise Java (Optional, je nach Interesse)

Dauer: fortlaufend Ziel: Einsatz von Java im produktiven Backend-Umfeld erlernen.

• Das Spring Ökosystem:
  • Dependency Injection (DI) und Inversion of Control (IoC).
  • Spring Boot für schnelle Applikationsentwicklung ohne komplexe Konfiguration.
  • Spring Data JPA (Integration von Hibernate für die Datenbankanbindung).
  • Spring Web für die Entwicklung von RESTful APIs.
• Microservices: Architekturmuster kennenlernen, Grundkonzepte von Docker.
• Alternative Frameworks: Quarkus oder Micronaut (besonders für Cloud-Native-Ansätze interessant).

Projekt-Meilensteine zur praktischen Anwendung

Um das Gelernte zu festigen, ist die Umsetzung eigener Projekte entscheidend. Theorie allein reicht nicht aus!

1. Meilenstein 1 (Nach Phase 1 & 2): Ein textbasiertes Spiel (z.B. Tic-Tac-Toe, Schiffe versenken, Hangman) oder ein Konsolen-Taschenrechner mit sauberem OOP-Ansatz.
2. Meilenstein 2 (Nach Phase 3): Ein Kontakt-Manager oder eine kleine Bibliothekverwaltung als Kommandozeilenanwendung. Daten sollen in einer Datei (`.txt` oder `.csv`) gespeichert und wiederhergestellt werden. Nutze das Collections-Framework für die Datenverwaltung im Speicher.
3. Meilenstein 3 (Nach Phase 4 & 5): Ein Multithreaded-Webscraper oder ein kleines Chat-Client-/Server-System mit Java Sockets. Wichtig: Die Kernlogik sollte mit JUnit-Tests abgesichert sein. Nutze Maven/Gradle als Build-Tool.
4. Meilenstein 4 (Nach Phase 6): Eine REST-API (z.B. ein Backend für eine To-Do-Liste oder einen Blog) mit Spring Boot inklusive Datenbankanbindung (H2 oder PostgreSQL) und Absicherung der Endpunkte mit Spring Security.

Ressourcen und Links

• Offizielle Dokumentation: Oracle Java Documentation / Tutorials
• Bücher:
  • "Java ist auch eine Insel" (Deutsch, hervorragend als umfassendes Nachschlagewerk).
  • "Effective Java" von Joshua Bloch (Englisch, ein Muss, wenn die Grundlagen sitzen!).
• Plattformen für kleine Programmieraufgaben (Katas): HackerRank, LeetCode, Codewars.
• Interaktive Kurse: Codecademy, Udemy, Pluralsight, JetBrains Academy (Hyperskill).

---

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).