Clean Code in Java: Prinzipien von Clean Code mit Beispielen

Einleitung: Warum sauberer Code kein Luxus, sondern eine Notwendigkeit ist

Jeder Entwickler ist schon einmal auf Code gestoßen, den man ohne eine Tasse Kaffee und Meditation nicht verstehen kann. Variablen mit Namen wie a, b, temp, Methoden mit 500 Zeilen Länge und Kommentare wie „Hier ist Magie, nicht anfassen“ sind sichere Anzeichen dafür, dass sich das Projekt in „Legacy-Code“ verwandelt. Clean Code ist eine Philosophie und eine Sammlung von Praktiken, die Code lesbar, leicht wartbar und erweiterbar machen.

In diesem Artikel analysieren wir die Schlüsselprinzipien von Clean Code in der Sprache Java anhand konkreter Beispiele. Sie erfahren, wie Sie Code schreiben, den Sie selbst und Ihre Kollegen in einem halben Jahr dankbar lesen werden.

Prinzip 1: Aussagekräftige Namen

Der Name einer Variable, Methode oder Klasse sollte drei Fragen beantworten: Was ist das, wozu dient es und wie verwendet man es? Ein schlechter Name ist die Hauptquelle für Verwirrung.

Schlechtes Beispiel

public List<Integer> getList(int a) {    List<Integer> list = new ArrayList<>();    for (int i = 0; i < a; i++) {        list.add(i * 2);    }    return list;}

Was macht diese Methode? Was ist a? Gibt sie eine Liste gerader Zahlen zurück? Oder multipliziert sie einfach etwas mit zwei?

Gutes Beispiel (Clean Code)

public List<Integer> generateEvenNumbers(int count) {    List<Integer> evenNumbers = new ArrayList<>();    for (int i = 0; i < count; i++) {        evenNumbers.add(i * 2);    }    return evenNumbers;}

Jetzt ist alles ohne Kommentare klar: Die Methode generiert eine Liste gerader Zahlen mit einer bestimmten Länge.

Namensregeln

• Klassen: Substantive (User, PaymentProcessor)
• Methoden: Verben (saveUser(), calculateTotal())
• Variablen: Sinnvolle Substantive (userName, totalPrice)
• Vermeiden Sie: Abkürzungen (usrNm), einbuchstabige Namen (außer für Schleifenzähler i, j)

Prinzip 2: Kleine Methoden mit einer einzigen Verantwortlichkeit

Eine Methode sollte nur eine Sache tun und diese gut machen. Wenn eine Methode mit der Konjunktion „und“ beschrieben werden kann (macht zuerst A, UND dann B), dann muss sie aufgeteilt werden.

Schlechtes Beispiel: Monolith

public void processOrder(Order order) {    // Validierung    if (order.getItems().isEmpty()) {        throw new IllegalArgumentException("Order is empty");    }    // Berechnung der Gesamtsumme    double total = 0;    for (Item item : order.getItems()) {        total += item.getPrice() * item.getQuantity();    }    // E-Mail senden    EmailService.send(order.getCustomerEmail(), "Your order total: " + total);    // In DB speichern    orderRepository.save(order);}

Diese Methode macht 4 Dinge: validieren, berechnen, E-Mail senden und speichern. Wenn etwas kaputt geht, muss die Ursache in der gesamten Methode gesucht werden.

Gutes Beispiel: Saubere Methoden

public void processOrder(Order order) {    validateOrder(order);    double total = calculateTotal(order);    sendConfirmationEmail(order, total);    saveOrder(order);}

private void validateOrder(Order order) {    if (order.getItems().isEmpty()) {        throw new IllegalArgumentException("Order cannot be empty");    }}

private double calculateTotal(Order order) {    return order.getItems().stream()            .mapToDouble(item -> item.getPrice() * item.getQuantity())            .sum();}

private void sendConfirmationEmail(Order order, double total) {    String message = "Your order total: " + total;    EmailService.send(order.getCustomerEmail(), message);}

private void saveOrder(Order order) {    orderRepository.save(order);}

Jede Methode ist ein Baustein. Sie l