Java 25: Was ist neu und wo man es praktisch lernen kann

Während andere Plattformen auf das offizielle Release warten, haben wir bereits unseren Kurs gestartet. Wir warten nicht darauf, dass alle über das neue Java diskutieren — wir erstellen sofort den Kurs 💪

Als wir CodeGym 2014 starteten, war unser Ziel einfach — Menschen praktische Programmierfähigkeiten zu vermitteln, nicht schöne Präsentationen darüber, "wie wichtig es ist, die Grundlagen zu lernen". In über 10 Jahren haben mehr als 2 Millionen Menschen unsere Kurse absolviert. Jetzt haben wir den weltweit ersten Kurs zu Java 25 erstellt und ich möchte Ihnen erzählen, was dort interessant ist.

Compact Source Files — Java für Anfänger

Die auffälligste Änderung in Java 25 ist die vereinfachte Syntax für Einsteiger. Jetzt können Sie Programme schreiben, ohne explizit Klassen zu deklarieren:

// Früher war das nötig
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

// Jetzt reicht das aus
void main() {
    IO.println("Hello, World!");
}

Wenn eine .java-Datei Methoden oder Felder außerhalb einer expliziten Klassendeklaration hat, erstellt der Compiler automatisch eine implizite Top-Level-Klasse. Für diejenigen, die das Programmieren lernen, senkt dies erheblich die Einstiegshürde.

Instance Main Methods — ohne static und String[]

Java 25 erlaubt die Verwendung von Instance-Methoden als Programmeingang. Nicht mehr nötig, Anfängern zu erklären, was static bedeutet:

void main() {
    // Normale Instance-Methode
    processData();
}

void processData() {
    IO.println("Daten werden verarbeitet...");
}

Wenn eine Klasse keine geeignete static main-Methode hat, sucht der Java-Launcher nach einer Instance main-Methode und erstellt automatisch eine Klasseninstanz.

java.lang.IO — Einfache Ein-/Ausgabe

Die neue Klasse java.lang.IO vereinfacht die Konsolenarbeit. Nicht mehr nötig, sich System.out.println zu merken:

void main() {
    String name = IO.readln("Geben Sie Ihren Namen ein: ");
    IO.println("Hallo, " + name + "!");
}

Die Klasse befindet sich im java.lang-Paket und ist daher ohne Import verfügbar. Es gibt Methoden für Ausgabe, Eingabe und das Lesen von Strings mit Eingabeaufforderung.

Flexible Constructor Bodies — Flexible Konstruktoren

In Java 25 können Sie Operationen vor dem Aufruf von super() oder this() ausführen:

public class User {
    private final String email;
    private final String domain;
    
    public User(String email) {
        // Operationen vor super()-Aufruf
        this.domain = extractDomain(email);
        validateDomain(domain);
        
        super(); // Aufruf des Object-Konstruktors
        
        this.email = email;
    }
    
    private String extractDomain(String email) {
        return email.substring(email.indexOf('@') + 1);
    }
}

Dies ermöglicht die Initialisierung von Feldern und die Durchführung von Validierungen vor der Objekterstellung und macht Konstruktoren natürlicher.

Module Import Declarations — Vereinfachte Imports

JEP 511 führt die Möglichkeit ein, alle Pakete eines Moduls mit einer Zeile zu importieren:

import module java.base;

// Jetzt sind alle Klassen von java.base ohne explizite Imports verfügbar
void main() {
    var list = new ArrayList<String>();
    var file = new File("data.txt");
    var decimal = new BigDecimal("123.45");
}

Dies ist besonders nützlich bei der Arbeit mit großen Modulen, bei denen Sie viele Klassen benötigen.

Stable Values — Optimierte Konstanten

Neue API für die Arbeit mit unveränderlichen Werten, die später initialisiert werden können:

class Configuration {
    static final StableValue<String> DATABASE_URL = 
        StableValue.of(() -> loadFromConfig("db.url"));
        
    void connectToDatabase() {
        String url = DATABASE_URL.get(); // Lazy Initialisierung
        // Datenbankverbindung
    }
}

Stable Values helfen, die Startzeit von Anwendungen zu optimieren und bieten Thread-Sicherheit für verzögerte Initialisierung.

Primitive Types in Patterns — Erweitetes Pattern Matching

Java 25 erweitert Pattern Matching auf alle primitiven Typen:

static String classify(Number n) {
    return switch (n) {
        case int i -> "Integer: " + i;
        case long l -> "Long: " + l;
        case double d -> "Double: " + d;
        case float f -> "Float: " + f;
        default -> "Unbekannter Zahlentyp";
    };
}

Jetzt können Sie Pattern Matching mit int, long, double, float und anderen Primitiven in Switch-Expressions und instanceof verwenden.

Compact Object Headers — Speichereinsparung

In Java 25 werden die Größen der Objekt-Header von 96-128 Bit auf 64 Bit auf 64-Bit-Architekturen reduziert:

// Jedes Objekt benötigt jetzt weniger Speicher
List<String> list = new ArrayList<>(); // Weniger Overhead
Map<String, User> users = new HashMap<>(); // Einsparungen bei jedem Entry

Dies ist besonders bei Anwendungen mit vielen Objekten bemerkbar — Microservices und Anwendungen mit großen Heaps.

Scoped Values — Sicherer Kontext

Die finale Version von Scoped Values ermöglicht das Übertragen unveränderlicher Daten zwischen Methoden und Threads:

private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

public void handleRequest(User user) {
    ScopedValue.where(CURRENT_USER, user)
        .run(() -> {
            processOrder();  // Innen Zugriff auf user über CURRENT_USER.get()
            sendNotification();
            logActivity();
        });
}

Im Gegensatz zu ThreadLocal sind Scoped Values einfacher zu verwenden, haben weniger Overhead und funktionieren besser mit virtuellen Threads.

JFR-Verbesserungen — Bessere Profilerstellung

Java 25 verbessert Java Flight Recorder mit drei neuen Funktionen:

JFR Cooperative Sampling — sicherere Stack-Trace-Sammlung ohne Bias und mit Unterstützung für gleichzeitiges Stack-Walking.

JFR Method Timing & Tracing — Verfolgung der Ausführungszeit bestimmter Methoden ohne Codeänderungen:

java -XX:StartFlightRecording:jdk.MethodTiming#methods=com.myapp.Service.* MyApp

CPU-Time Profiling on Linux — präzise CPU-Zeit-Profilerstellung mit Linux-Kernel-Funktionen.

Key Derivation Functions API

Neue API für die Arbeit mit Schlüssel-Ableitungsfunktionen (KDF):

// Beispiel für die Verwendung von KDF zur Generierung abgeleiteter Schlüssel
KeyDerivationFunction kdf = KeyDerivationFunction.getInstance("PBKDF2WithHmacSHA256");
SecretKey derivedKey = kdf.deriveKey(password, salt, iterations, keyLength);

Dies ist kritisch wichtig für kryptografische Anwendungen und die Implementierung sicherer Passwortspeicherung.

Warum Java 25 lernen

Java entwickelt sich schnell — neue LTS-Versionen erscheinen alle 3 Jahre. Diejenigen, die die neuen Features zuerst beherrschen, erhalten einen Vorteil auf dem Arbeitsmarkt.

Java 25 ist ein LTS-Release mit 5 Jahren Support von Oracle. Unternehmen werden auf diese Version migrieren und nach Entwicklern suchen, die die neuen Sprachfähigkeiten kennen.

Der erste Java 25-Kurs

Als Oracle das Veröffentlichungsdatum von Java 25 ankündigte, entschieden wir uns, nicht zu warten. CodeGym war schon immer voraus — wir waren die ersten, die gamifizierte Programmierausbildung schufen, die ersten, die interaktive Aufgaben mit automatischer Überprüfung erstellten.

Jetzt sind wir die ersten, die Ihnen die Möglichkeit geben, Java 25 praktisch zu lernen. Der Kurs umfasst sowohl Java 25-Neuerungen als auch wichtige Features aus vorherigen Versionen — Lambdas und Stream API aus Java 8, Module aus Java 9, var aus Java 10, Text Blocks aus Java 13, Records aus Java 14, Pattern Matching aus Java 17, Virtual Threads aus Java 21.

Was ist im Kurs enthalten:

• 325+ Vorlesungen, die jede Java 25-Neuerung erklären
• 880+ Aufgaben von einfach bis Enterprise-Niveau
• KI-Mentor, der Code analysiert und Empfehlungen gibt
• IntelliJ IDEA-Integration — lernen Sie mit professionellen Tools
• Große Projekte — erstellen Sie echte Anwendungen mit neuen Technologien

Praxis — Die Grundlage des Lernens

Nach Jahren des Unterrichtens habe ich eine einfache Wahrheit verstanden: Theorie ohne Praxis ist Zeitverschwendung. Sie können die gesamte Dokumentation über Compact Source Files lesen, aber erst wenn Sie mehrere Programme mit der neuen Syntax schreiben, werden Sie die Bequemlichkeit spüren.

Im Kurs wird jede Java 25-Neuerung sofort mit Praxis verstärkt. Lernen Sie Flexible Constructor Bodies — schreiben Sie ein sicheres Objektinitialisierungssystem. Meistern Sie Scoped Values — erstellen Sie eine Multi-Thread-Anwendung mit Kontextübertragung. Verstehen Sie Module Import Declarations — vereinfachen Sie die Struktur großer Projekte.

KI-Mentor im Kurs

Das interessanteste Feature unseres Kurses ist die KI, die den Code der Studenten analysiert. Das sind keine generischen Ratschläge von ChatGPT, sondern ein spezialisiertes System, das:

• Den Kontext jeder Kursaufgabe kennt
• Den Programmierstil analysiert
• Personalisierte Empfehlungen gibt

Gamifiziertes Lernen

Programmieren kann langweilig sein, wenn Sie es falsch lernen. Deshalb ist die CodeGym-Ausbildung wie ein Spiel aufgebaut: Level, Erfolge, Bewertungen.

Im Java 25-Kurs:

• Erfolge für das Lösen von Aufgaben unterschiedlicher Schwierigkeit
• Allgemeine Bestenliste der Studenten
• Spielähnliche Level

Von Null auf Arbeitsbereitschaft

Der Kurs ist so aufgebaut, dass selbst ein Anfänger nach 65 Leveln Kenntnisse hat, die für die Arbeit in einem seriösen Unternehmen ausreichen. Der vollständige Kurslehrplan umfasst das Lernen von modernem Java 25, deckt aber auch ab:

• Moderne Syntax und neue Operatoren
• OOP mit neuen Sprachfähigkeiten
• Collections und Stream API
• Dateivorgänge über moderne API
• Multithreading und Thread-Management

IntelliJ IDEA Plugin

Eines der Features von CodeGym ist das IntelliJ IDEA Plugin. Studenten lösen Aufgaben direkt in einer professionellen Entwicklungsumgebung mit Syntax-Highlighting, Auto-Vervollständigung und Debugger.

Sofortige Lösungsüberprüfung

Bei CodeGym können Sie eine Aufgabe lösen und das Ergebnis in wenigen Sekunden erfahren. Das System überprüft automatisch den Code, führt Tests durch und gibt Feedback.

Für Java 25 versteht das Überprüfungssystem:

• Neue Compact Source Files-Syntax
• Instance Main Methods
• Flexible Constructor Bodies
• Module Import Declarations

Warum CodeGym für Java 25 lernen

In über 10 Jahren Arbeit haben wir verstanden, wie man Programmieren effektiv unterrichtet. Recruiter in Tech-Unternehmen kennen CodeGym und fragen oft in Interviews: "Welches ist Ihr Level auf CodeGym?" Nicht weil wir sie dafür bezahlen, sondern weil sie wissen — wenn jemand Level 40 erreicht hat, kann er programmieren, nicht nur Syntax auswendig lernen.

Der Java 25-Kurs ist die Weiterentwicklung unserer Methodik. Dieselbe praktische Ausrichtung, aber mit den modernsten Technologien.

Jetzt mit dem Lernen beginnen

Java 25 ist bereits erschienen und Sie können es jetzt lernen — während die Konkurrenz Release Notes liest. Unser Kurs enthält alle Innovationen mit praktischen Beispielen.

65 Level praktischer Aufgaben, KI-Mentor, Integration mit professionellen Tools — alles damit Sie modernes Java schnell und effektiv beherrschen.

Werden Sie ein Java-Entwickler, der bereit für 2025 ist.