Häufige Code-Smells in Java und wie man sie behebt

Code-Smells weisen auf potenzielle Probleme in Ihrem Java-Code hin, die sich auf Wartbarkeit, Lesbarkeit und Leistung auswirken. Es sind zwar nicht immer Fehler, aber durch deren Behebung bleibt Ihre Codebasis sauber und effizient. Dieser Artikel untersucht fünf gängige Java-Code-Gerüche und bietet Beispiele, Erklärungen und verbesserte Lösungen.

---

1. Überlange Methoden

Das Problem: Zu lange Methoden behindern Lesbarkeit, Tests und Wartung. Selbst mit Hilfsmethoden verstößt die Kombination mehrerer Abstraktionsebenen gegen das Single-Responsibility-Prinzip (SRP).

Beispiel:

<code class="language-java">public void processOrder(Order order) {
    validateOrder(order);
    calculateDiscount(order);
    updateInventory(order);
    generateInvoice(order);
    sendNotification(order);
}</code>

processOrder vermischt unabhängige Aufgaben (Validierung, Rabattberechnung, Bestandsaktualisierungen, Rechnungsstellung und Benachrichtigungen), was es schwierig macht, Änderungen ohne unbeabsichtigte Folgen vorzunehmen.

Lösung: Umgestaltung in kleinere, fokussierte Methoden. Entwurfsmuster wie das Befehlsmuster oder das Pipeline-Muster verbessern die Modularität.

Umgestalteter Code (Befehlsmuster):

<code class="language-java">interface OrderCommand { void execute(Order order); }

class ValidateOrderCommand implements OrderCommand {
    public void execute(Order order) { /* Validation logic */ }
}

// ... other commands (ApplyDiscountCommand, etc.)

class OrderProcessor {
    List<OrderCommand> commands;

    public OrderProcessor(List<OrderCommand> commands) { this.commands = commands; }

    public void processOrder(Order order) {
        for (OrderCommand command : commands) { command.execute(order); }
    }
}

// Usage
List<OrderCommand> commands = List.of(new ValidateOrderCommand(), new ApplyDiscountCommand(), ...);
OrderProcessor processor = new OrderProcessor(commands);
processor.processOrder(new Order());</code>

Vorteile: Verbesserte Modularität, unabhängiges Testen und Wiederverwenden von Befehlen, einfaches Hinzufügen neuer Schritte.

---

2. Gottklassen

Das Problem:Eine „Gottklasse“ übernimmt zu viele Verantwortlichkeiten, was zu hoher Kopplung und schlechter Wartbarkeit führt.

Beispiel:

<code class="language-java">public class OrderManager {
    public void createOrder() { /* Implementation */ }
    public void updateOrder() { /* Implementation */ }
    public void deleteOrder() { /* Implementation */ }
    public void validatePayment() { /* Implementation */ }
    public void sendInvoice() { /* Implementation */ }
}</code>

Lösung:Aufteilung der Verantwortlichkeiten in kleinere, fokussierte Klassen.

Überarbeiteter Code:

<code class="language-java">public class OrderService {
    public void createOrder() { /* Implementation */ }
    // ... other order-related methods
}

public class PaymentService {
    public void validatePayment() { /* Implementation */ }
}

public class NotificationService {
    public void sendInvoice() { /* Implementation */ }
}</code>

Vorteile: Reduzierte Kopplung, verbesserte Modularität, einfachere Wartung, Tests und unabhängige Erweiterung.

---

3. Magische Zahlen

Das Problem:Die Verwendung von Literalzahlen verringert direkt die Klarheit des Codes und macht Änderungen riskant.

Beispiel:

<code class="language-java">public double calculateDiscount(double totalAmount) {
    return totalAmount > 1000 ? totalAmount * 0.1 : totalAmount;
}</code>

Lösung: Ersetzen Sie Literalzahlen durch benannte Konstanten.

Überarbeiteter Code:

<code class="language-java">private static final double DISCOUNT_THRESHOLD = 1000;
private static final double DISCOUNT_RATE = 0.1;

public double calculateDiscount(double totalAmount) {
    return totalAmount > DISCOUNT_THRESHOLD ? totalAmount * DISCOUNT_RATE : totalAmount;
}</code>

Vorteile: Verbesserte Lesbarkeit, reduziertes Fehlerrisiko bei Aktualisierungen, klarere Geschäftslogik.

---

4. Doppelter Code

Das Problem: Wiederholter Code über Methoden oder Klassen hinweg führt zu Inkonsistenzen und Wartungsproblemen.

Beispiel:

<code class="language-java">public double calculateTax(double amount) { return amount * 0.18; }
public double calculateDiscount(double amount) { return amount * 0.1; }</code>

Lösung:Allgemeine Logik in eine wiederverwendbare Methode abstrahieren.

Überarbeiteter Code:

<code class="language-java">private double applyRate(double amount, double rate) { return amount * rate; }

public double calculateTax(double amount) { return applyRate(amount, 0.18); }
public double calculateDiscount(double amount) { return applyRate(amount, 0.1); }</code>

Vorteile: Eliminiert Redundanz, gewährleistet Konsistenz, vereinfacht Modifikation und Erweiterung.

---

5. Übermäßige Parameterlisten

Das Problem:Methoden mit vielen Parametern sind schwer zu lesen und zu verstehen und bei Aufrufen fehleranfällig.

Beispiel:

<code class="language-java">public void processOrder(Order order) {
    validateOrder(order);
    calculateDiscount(order);
    updateInventory(order);
    generateInvoice(order);
    sendNotification(order);
}</code>

Lösung: Kapseln Sie Parameter innerhalb eines Objekts oder verwenden Sie ein Builder-Muster.

Überarbeiteter Code:

<code class="language-java">interface OrderCommand { void execute(Order order); }

class ValidateOrderCommand implements OrderCommand {
    public void execute(Order order) { /* Validation logic */ }
}

// ... other commands (ApplyDiscountCommand, etc.)

class OrderProcessor {
    List<OrderCommand> commands;

    public OrderProcessor(List<OrderCommand> commands) { this.commands = commands; }

    public void processOrder(Order order) {
        for (OrderCommand command : commands) { command.execute(order); }
    }
}

// Usage
List<OrderCommand> commands = List.of(new ValidateOrderCommand(), new ApplyDiscountCommand(), ...);
OrderProcessor processor = new OrderProcessor(commands);
processor.processOrder(new Order());</code>

Vorteile: Verbessert die Lesbarkeit und Erweiterbarkeit; Das Hinzufügen von Parametern erfordert keine Änderungen der Methodensignatur.

---

Die proaktive Beseitigung von Code-Smells verhindert größere Designprobleme und reduziert technische Schulden, was zu robusteren und wartbareren Java-Anwendungen führt. Denken Sie an die Prinzipien von DRY (Don't Repeat Yourself) und SRP (Single Responsibility Principle) für saubereren und effizienteren Code.

Das obige ist der detaillierte Inhalt vonHäufige Code-Smells in Java und wie man sie behebt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!