Funktional vs. OOP in Java: Was wählt man 2024?

Funktionaler vs. objektorientierter Ansatz in Java: Was wählt der moderne Entwickler?

Die Welt von Java ist ein Schlachtfeld zweier Giganten. Auf der einen Seite die klassische objektorientierte Programmierung (OOP), mit der eine ganze Generation von Entwicklern aufgewachsen ist. Auf der anderen Seite der an Fahrt gewinnende funktionale Ansatz, der mit der Veröffentlichung von Java 8 in das Ökosystem eingebrochen ist und bis heute die Debatte tobt: „Brauchen wir das überhaupt?“.

Wenn Sie in Java programmieren, stehen Sie täglich vor dieser Wahl. Lohnt es sich, eine ganze Klasse mit Methoden für eine einfache Filterung zu erstellen? Oder ist es besser, eine Kette von Lambdas zu werfen und es zu vergessen? In diesem Artikel werden wir uns nicht auf eine Seite schlagen. Wir werden beide Ansätze anhand realer Beispiele analysieren, sie nach wichtigen Metriken vergleichen und Ihnen helfen zu verstehen, wann Sie welches Werkzeug aus dem Arsenal holen sollten.

Kurzer Exkurs: Wie sind wir so weit gekommen?

Java wurde ursprünglich als rein objektorientierte Sprache konzipiert. Alles ist ein Objekt. Selbst ein String ist ein Objekt der Klasse String. Klassen, Vererbung, Polymorphismus – das war die Religion. Aber die Zeit verging, und die Entwickler erkannten: OOP modelliert die reale Welt hervorragend (Maschinen, Mitarbeiter, Bestellungen), kommt aber mit der Verarbeitung von Datenströmen furchtbar zurecht.

Da traten Lambda-Ausdrücke und die Stream API auf den Plan. Java wurde keine funktionale Sprache (wie Haskell oder Scala), übernahm aber das Beste aus diesem Paradigma. Jetzt haben wir die Wahl: eine for-Schleife innerhalb einer Klassenmethode schreiben oder filter().map().collect() verwenden.

Objektorientierter Ansatz: Der Klassiker

OOP in Java basiert auf vier Säulen: Kapselung, Vererbung, Polymorphismus und Abstraktion. Wenn Sie mit Geschäftslogik arbeiten, die Entitäten enthält (Benutzer, Bestellung, Produkt), ist OOP die natürliche Wahl.

Hier ist ein Beispiel für eine klassische Aufgabe: Finden Sie die Summe aller Bestellungen eines Kunden, die im Jahr 2024 getätigt wurden.

Objektorientierte Lösung:

import java.util.List;\n\npublic class OrderService {\n\n    public double calculateTotal2024(List<Order> orders) {\n        double total = 0.0;\n        for (Order order : orders) {\n            if (order.getYear() == 2024) {\n                total += order.getAmount();\n            }\n        }\n        return total;\n    }\n}\n\nclass Order {\n    private int year;\n    private double amount;\n\n    public Order(int year, double amount) {\n        this.year = year;\n        this.amount = amount;\n    }\n\n    public int getYear() { return year; }\n    public double getAmount() { return amount; }\n}

Alles ist transparent, lesbar, leicht zu debuggen. Jeder Junior wird verstehen, was hier passiert. Aber es gibt einen Haken: Der Code ist imperativ. Wir sagen wie es gemacht wird (erstelle eine Variable, gehe die Liste durch, prüfe die Bedingung, addiere).

Funktionaler Ansatz: Deklarativ schreiben

Funktionale Programmierung in Java dreht sich darum, was wir erreichen wollen, nicht wie. Wir verwenden Funktionen höherer Ordnung, Unveränderlichkeit und das Fehlen von Seiteneffekten.

Dieselbe Aufgabe, aber im funktionalen Stil:

Funktionale Lösung:

import java.util.List;\n\npublic class OrderServiceFunctional {\n\n    public double calculateTotal2024(List<Order> orders) {\n        return orders.stream()\n                .filter(order -> order.getYear() == 2024)\n                .mapToDouble(Order::getAmount)\n                .sum();\n    }\n}

Nur drei Zeilen. Keine veränderlichen Variablen, keine Schleifen. Wir sagen einfach: „Nimm den Stream, filtere nach Jahr, nimm die Beträge, addiere sie.“ Das ist der deklarative Stil.

Vergleich: Wo gewinnt was?

Lassen Sie uns aufschlüsseln, in welchen Szenarien sich jeder Ansatz besser zeigt.

1. Lesbarkeit und Prägnanz

Gewinner: Funktionaler Ansatz