Die soliden Prinzipien für Java -Entwickler erklärt

Für das Prinzip (einzelne Verantwortung "(SRP) muss eine Klasse nur für eine Funktion verantwortlich sein, z. 2. Das Öffnungs- und Schlussprinzip (OCP) erfordert das Öffnen und Schließen für Erweiterungen und Schließen für Modifikationen, z. B. das Hinzufügen neuer Grafiken über die Formoberfläche ohne Änderung des Taschenrechners. 3. Das Richter Ersatzprinzip (LSP) erfordert, dass Unterklassen die übergeordnete Klasse ersetzen können, ohne das Programm zu zerstören, z. 4. Das Interface-Isolationsprinzip (ISP) erfordert, dass Clients nicht auf unerwünschten Schnittstellen stützen sollten, z. 5. Das Abhängigkeitsinversionsprinzip (DIP) erfordert, dass hochrangige Module nicht auf Modulen auf niedriger Ebene beruhen, und beide stützen sich auf Abstraktionen, wie z. Diese fünf Prinzipien verbessern gemeinsam die Wartbarkeit, Erweiterbarkeit und Testbarkeit des Java -Code.

Die soliden Prinzipien sind eine Reihe von fünf Designprinzipien, mit denen Software-Designs verständlicher, flexibler und wartbarer werden sollen-insbesondere in der objektorientierten Programmierung. Bei Java -Entwicklern hilft das Aufbringen von Solid -Aufbau von Systemen, die leichter zu erweitern, zu testen und zu reflektieren sind. Lassen Sie uns jedes Prinzip mit praktischen Java -Beispielen und klaren Erklärungen aufschlüsseln.

1. Prinzip der Einzelverantwortung (SRP)

Eine Klasse sollte nur einen Grund haben, sich zu ändern.

Mit anderen Worten, eine Klasse sollte für einen einzelnen Teil der Funktionalität der Anwendung verantwortlich sein. Wenn eine Klasse mehrere Aufgaben erledigt, kann das Ändern des anderen das andere brechen.

Beispiel (Verstoß):

 öffentliche Klasse Orderprozessor {
    public void ProcessOrder (Order Order) {
        // Bestellung in der Datenbank speichern
        Savetodatabase (Order);

        // Bestätigungs -E -Mail senden
        sendemail (order.getCustomeremail ());
    }

    private void Savetodatabase (Bestellauftrag) { / * ... * /}
    private void sendemail (String -E -Mail) { / * ... * /}
}

Hier übernimmt OrderProcessor beide Datenpersistenz und Kommunikation - zwei Verantwortlichkeiten.

Refactored (SRP -konform):

 öffentliche Klasse OrderRepository {
    public void save (Order Order) { / * ... * /}
}

öffentliche Klasse Emailservice {
    public void sendConfirmation (String -E -Mail) { / * ... * /}
}

öffentliche Klasse Orderprozessor {
    private orderRepository repository;
    privater E -Mail -Service -E -Mail -Service;

    public void ProcessOrder (Order Order) {
        repository.save (order);
        EmailService.SendConfirmation (order.getCustomeremail ());
    }
}

Jetzt hat jede Klasse einen einzigen Job. Änderungen an der E -Mail -Logik haben keinen Einfluss auf das Speichern von Daten.

2. Offener/geschlossenes Prinzip (OCP)

Softwareentitäten sollten für die Erweiterung geöffnet sein, jedoch zur Änderung geschlossen werden.

Sie sollten in der Lage sein, neue Funktionen hinzuzufügen, ohne den vorhandenen Code zu ändern.

Beispiel (Verstoß):

 public class AreaCalculator {
    public double calculatearea (list <Object> formes) {
        doppeltes Gesamt = 0;
        für (Objektform: Formen) {
            if (Forminstanz des Kreises) {
                Kreis C = (Kreis) Form;
                Total = math.pi * C.Radius * C.Radius;
            } else if (Forminstanz von Rechteck) {
                Rechteck r = (Rechteck) Form;
                insgesamt = R. Width * r.height;
            }
        }
        Return Total;
    }
}

Jedes Mal, wenn Sie eine neue Form hinzufügen, müssen Sie diese Methode ändern.

Refactored (OCP -konform):

 öffentliche Schnittstellenform {
    doppelte Fläche ();
}

Der öffentliche Klassenkreis implementiert Form {
    privates Doppelradius;
    public Double Area () {return math.pi * radius * radius; }
}

öffentliche Klasse Rechteck implementiert Form {
    private doppelte Breite, Höhe;
    public Double Area () {Return Width * Höhe; }
}

public class AreaCalculator {
    public double calculatearea (list <Sape> formes) {
        return forces.stream ()
                     .Maptodouble (Form :: Bereich)
                     .Summe();
    }
}

Jetzt können Sie neue Formen (z. B. Dreieck) hinzufügen, ohne AreaCalculator zu berühren.

3. Liskov Substitution Prinzip (LSP)

Subtypen müssen durch ihre Grundtypen ersetzt werden, ohne die Richtigkeit des Programms zu ändern.

Wenn eine Klasse von einem anderen erbt, sollte sie das erwartete Verhalten nicht brechen.

Beispiel (Verstoß):

 öffentliche Klasse Rechteck {
    geschützte intbreite, Höhe;

    public void setwidth (int width) {this.width = width; }
    public void Seteight (int Höhe) {this.height = Höhe; }

    public int getArea () {Return Width * Höhe; }
}

Der öffentliche Klasse Square erweitert Rechteck {
    @Override
    public void setwidth (int width) {
        Super.Setwidth (Breite);
        Super.SetHeight (Breite);
    }

    @Override
    public void Seteight (int Höhe) {
        Super.SetHeight (Höhe);
        Super.Setwidth (Höhe);
    }
}

Wenn eine Methode nun ein Rectangle erwartet und die Breite und Höhe unabhängig voneinander setzt, bricht ein Square diese Annahme.

Besserer Ansatz: Vermeiden Sie die Vererbung, wenn Verhaltensverträge gewalttätig sind. Verwenden Sie Komposition oder separate Hierarchien.

 öffentliche Schnittstellenform {
    int Area ();
}

öffentliche Klasse Rechteck implementiert Form {
    Private int Breite, Größe;
    // Setzer und Bereich ()
}

Public Class Square implementiert Form {
    private int Seite;
    // Area = Seite * Seite
}

Jetzt keine irreführende Erbschaft. LSP ist erhalten.

4. Prinzip der Schnittstellensegregation (ISP)

Kunden sollten nicht gezwungen sein, sich auf Schnittstellen zu verlassen, die sie nicht verwenden.

Big, monolithische Schnittstellen machen Klassen implementieren Methoden, die sie nicht benötigen.

Beispiel (Verstoß):

 öffentliche Schnittstellenmaschine {
    void print ();
    void scan ();
    void fax ();
}

öffentliche Klasse OldPrinter implementiert Maschine {
    public void print () {System.out.println ("Druck"); }
    public void scan () {neue nicht unterstützte OperationException () werfen; }
    public void fax () {neue nicht unterstützte OperationException () werfen; }
}

OldPrinter ist gezwungen, irrelevante Methoden zu implementieren.

Refactored (ISP -konform):

 Öffentlicher Schnittstellendrucker {
    void print ();
}

öffentlicher Schnittstellenscanner {
    void scan ();
}

öffentliche Schnittstelle Faxmachine {
    void fax ();
}

öffentliche Klasse OldPrinter implementiert Drucker {
    public void print () {System.out.println ("Druck"); }
}

öffentliche Klasse MultifunktionDevice implementiert Drucker, Scanner, Faxmachine {
    public void print () { / * ... * /}
    public void scan () { / * ... * /}
    public void fax () { / * ... * /}
}

Jetzt implementieren Klassen nur das, was sie unterstützen.

5. Abhängigkeitsinversionsprinzip (DIP)

Auf hohen Modulen sollten nicht von Modulen auf niedrigem Niveau abhängen. Beide sollten von Abstraktionen abhängen.

Außerdem: Abstraktionen sollten nicht von Details abhängen. Details sollten von Abstraktionen abhängen.

Dies ermöglicht eine lose Kopplung und einfachere Tests.

Beispiel (Verstoß):

 öffentliche Klasse orderService {
    private mySqldatabase database = new mySqldatabase ();

    public void Saveorder (Bestellung) {
        Datenbank.Save (Order);
    }
}

OrderService ist eng mit MySQLDatabase gekoppelt. Datenbanken schwer zu testen oder zu wechseln.

Refactored (dip konform):

 öffentliche Schnittstellendatenbank {
    void Save (Bestellung);
}

öffentliche Klasse Mysqldatabase implementiert die Datenbank {
    public void save (Order Order) { / * ... * /}
}

öffentliche Klasse orderService {
    private Datenbankdatenbank;

    public orderService (Datenbankdatenbank) {
        this.database = Datenbank;
    }

    public void Saveorder (Bestellung) {
        Datenbank.Save (Order);
    }
}

Jetzt hängt OrderService von der Database ab. Sie können jede Implementierung injizieren (MySQL, PostgreSQL, Mock usw.).

Mit Abhängigkeitsinjektionsrahmen (wie Frühling) wird dies noch leistungsfähiger.

Letzte Gedanken

Solide Prinzipien sind keine starre Regeln - sie sind Richtlinien, mit denen Sie sauberer und gepflegterer Java -Code schreiben können. Wenn Sie sie früh anwenden, können Sie später vor technischen Schulden ersparen.

• SRP : Ein Job pro Klasse.
• OCP : Erweitern, nicht ändern.
• LSP : Unterklassen sollten die Benutzer nicht überraschen.
• ISP : Kleine, fokussierte Schnittstellen.
• Dip : Abhängig von Abstraktionen, nicht von Beton.

Sie könnten zunächst wie Overkill fühlen, insbesondere in kleinen Projekten. Wenn Ihre Codebasis jedoch wächst, werden diese Prinzipien zu wesentlichen Werkzeugen zur Verwaltung der Komplexität.

Wenn Ihre Java -Klassen schwer zu testen, zu ändern oder wieder zu verwenden, sind Chancen im Grunde genommen ein oder mehrere solide Prinzipien gewalttätig.

Das obige ist der detaillierte Inhalt vonDie soliden Prinzipien für Java -Entwickler erklärt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!