Clean Code in Java: Prinzipien und Beispiele für Praktiker

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Clean Code in Java: Prinzipien und Beispiele in der Praxis

Jeder Java-Entwickler stößt früher oder später auf das Problem des "schmutzigen" Codes. Schwer lesbare Methoden, bedeutungslose Variablennamen, magische Zahlen und riesige Klassen – all das verlangsamt die Entwicklung, erhöht die Anzahl der Fehler und demotiviert das Team. Robert C. Martins Buch "Clean Code" ist zur Bibel für diejenigen geworden, die qualitativ hochwertige Software schreiben möchten. In diesem Artikel werden wir die wichtigsten Prinzipien von sauberem Code in Java erläutern und zeigen, wie man sie mit konkreten Beispielen in der Praxis anwendet.

1. Benennung von Variablen, Methoden und Klassen

Ein richtiger Name ist die halbe Miete. Der Name sollte die Absicht des Programmierers offenbaren. Wenn Sie den Methodenrumpf lesen müssen, um zu verstehen, was sie tut, ist der Name schlecht gewählt.

Schlechtes Beispiel:

int d; // vergangene Zeit in TagenList<Integer> lst = new ArrayList<>();public void proc(int a, int b) {    // ...}

Gutes Beispiel:

int elapsedTimeInDays;List<Integer> customerIds = new ArrayList<>();public void calculateTotalPrice(double basePrice, double discount) {    // ...}

Benennungsregeln:

Klassen und Interfaces – Substantive (Customer, OrderProcessor, PaymentService).
Methoden – Verben oder Verbkonstruktionen (saveCustomer, findById, isActive).
Variablen – aussagekräftige Substantive, die die Essenz der Daten widerspiegeln (userName, totalAmount).
Vermeiden Sie Abkürzungen – schreiben Sie fullName statt fn, sonst erinnern Sie sich in einem Monat selbst nicht mehr, was fn bedeutet.

2. Kleine Methoden und das Prinzip der einzigen Verantwortung

Eine Methode sollte nur eine Sache tun und diese gut machen. Wenn eine Methode mehr als 10-15 Codezeilen enthält oder mehrere Verschachtelungsebenen hat, ist das ein Signal zum Refactoring.

Schlechtes Beispiel (Methode macht zu viel):

public void processOrder(Order order) {    // 1. Validierung    if (order.getItems().isEmpty()) throw new IllegalArgumentException("Bestellung ist leer");    // 2. Rabattberechnung    double discount = 0;    if (order.getCustomer().isPremium()) discount = 0.1;    // 3. Berechnung des Endpreises    double total = 0;    for (Item item : order.getItems()) {        total += item.getPrice() * item.getQuantity();    }    total = total * (1 - discount);    // 4. Speichern in der Datenbank    orderRepository.save(order);    // 5. E-Mail senden    emailService.sendConfirmation(order.getCustomer().getEmail());}

Gutes Beispiel (Aufteilung in kleine Methoden):

public void processOrder(Order order) {    validateOrder(order);    double discount = calculateDiscount(order.getCustomer());    double totalPrice = calculateTotalPrice(order, discount);    order.setTotalPrice(totalPrice);    orderRepository.save(order);    sendConfirmationEmail(order.getCustomer());}

private void validateOrder(Order order) {    if (order.getItems().isEmpty()) {        throw new IllegalArgumentException("Bestellung darf nicht leer sein");    }}

private double calculateDiscount(Customer customer) {    return customer.isPremium() ? 0.1 : 0.0;}

private double calculateTotalPrice(Order order, double discount) {    double subtotal = order.getItems().stream()            .mapToDouble(item -> item.getPrice() * item.getQuantity())            .sum();    return subtotal * (1 - discount);}

private void sendConfirmationEmail(Customer customer) {    emailService.sendConfirmation(customer.getEmail());}