PHP-objektorientierte Programmierung: Lösen Sie die Nullwertprobleme in der Vererbung und das richtige Design von Klassenbeziehungen

In diesem Artikel werden die gemeinsamen Nullwertprobleme in der programmorientierten PHP-programmierten Programmierung eingehend untersucht und konzentriert sich darauf, wie das __construct-Methode als Klassenkonstruktor korrekt verwendet werden kann, um Objekteigenschaften zu initialisieren und wie die Vererbung (IS-A) und die Aggregation (HAS-A) -Beziehung zwischen den Klassen unterschieden und ordnungsgemäß angewendet werden. In bestimmten Code -Beispielen führen wir Entwicklern an, um Laufzeitfehler zu vermeiden, die durch den Missbrauch von Konstruktoren oder eine unsachgemäße Vererbungsdesign verursacht werden und die Codestruktur und -wartbarkeit optimieren.

1. Problemanalyse: Warum erscheint der Nullwert?

In der programmorientierten PHP-programmierten PHP-Programmen kann der Eigenschaftswert zu Null führen, wenn er versucht, ein Objekt zu erstellen und seinen Eigenschaften Werte zuzuweisen, wenn es nicht ordnungsgemäß ausgeführt wird. Im ursprünglichen Code stieß die Klinikklasse auf dieses Problem, als er versuchte, ein Patientenobjekt über die Astromenten -Daten -Methode hinzuzufügen.

 // Original Patient Class Fragment Class Patient {
    privat $ name;
    privates Alter;
    privates $ Gender;

    öffentliche Funktionsaufzeichnung ($ name, $ ay, $ Gender) {
        $ this-> name = $ name;
        $ this-> Alter = $ Alter;
        $ this-> Gender = $ Gender;
    }
    // ...
}

// Original Clinic Class Clinic erweitert den Patienten {
    private $ Patienten = [];

    öffentliche Funktion ordnungsgemäß ($ name, $ ay, $ Gender) {
        // Das Problem liegt: neuer Patient () wird hier aufgerufen
        // Der Konstruktor ist jedoch in der Patientenklasse nicht definiert, und record () wird nicht als $ this-> Patienten [] = neuer Patient ($ name, $ ay, $ Gender) bezeichnet.
    }
    // ...
}

Es gibt zwei Hauptgründe für die Ausgabe von Nullwert:

1. Fehlender oder missbräuchlicher Konstruktor: Eine Methode mit dem Namen "Record" wird in der Patientenklasse definiert, um Eigenschaften festzulegen, ist jedoch keine spezielle Methode für PHP __construct. Wenn ein Objekt über einen neuen Patienten (...) erstellt wird, sucht und führt PHP die __construct -Methode aus, um das Objekt standardmäßig zu initialisieren. Wenn __construct nicht existiert und es keinen anderen Weg gibt, die Datensatzmethode explizit aufzurufen, wenn das Objekt erstellt wird, behält der $ -Name, $ ay, $ Geschlechtereigenschaften des Patientenobjekts den Standardwert des Nullwerts bei.
2. Unangemessene Klassenerbschaftsbeziehung: Die Klinik erweitert der Patient die "is-a" -Be Beziehung von "Die Klinik ist ein Patient", was logisch unangemessen ist. Eine Klinik wird normalerweise im Patienten, nicht im Patienten selbst, verwaltet oder enthalten. Obwohl diese unangemessene Erbschaftsbeziehung nicht die direkte Ursache des Nullwerts ist, verwirrt es die Verantwortung der Klasse und erhöht die Komplexität des Codes und die Schwierigkeit des Verständnisses.

2. korrekte Verwendung des PHP -Konstruktors __construction

__construct in PHP ist eine spezielle Methode, die als Konstruktor bezeichnet wird. Diese Methode wird beim Erstellen einer Instanz einer Klasse mit dem neuen Schlüsselwort automatisch aufgerufen. Seine Hauptfunktion besteht darin, neu erstellte Objekte zu initialisieren, z. B. das Festlegen des Anfangswerts von Attributen, die Ausführung der erforderlichen Einstellungslogik usw.

Um das Problem zu lösen, dass das Patientenobjektattribut null ist, müssen wir die Datensatzmethode in __constructal umbenennen und sicherstellen, dass es die erforderlichen Parameter empfängt und festlegt, wenn das Objekt erstellt wird.

  Php
Klassenpatient {
    privat $ name;
    privates Alter;
    privates $ Gender;

    /**
     * Konstruktor: beim Erstellen eines Patientenobjekts automatisch aufgerufen und zur Initialisierung von Patienteninformationen verwendet.
     *
     * @param String $ Name Patientenname* @param int $ Alter Patienten Alter* @param String $ Gender Patient Geschlecht*/
    Öffentliche Funktion __construct ($ name, $ ay, $ Gender) {
        $ this-> name = $ name;
        $ this-> Alter = $ Alter;
        $ this-> Gender = $ Gender;
    }

    // den Patientnamen öffentliche Funktion erhalten GetName () {
        $ this-> name zurück;
    }

    // Erhalten Sie die öffentliche Funktion des Patienten des Patienten Getage () {
        $ this-> Alter zurückgeben;
    }

    // Erhalten Sie die öffentliche Funktion des Patienten des Patienten GetGender () {
        Rückgabe $ this-> Geschlecht;
    }
}
?>

Wenn wir einen neuen Patienten ("Patrick Star", 18, "männlich") ausführen, wird die __ -Construct -Methode automatisch ausgeführt und der übergebene Name, Alter und Geschlecht wird dem $ -Namen, $ AGE, $ -Gender -Attribute zugewiesen, um sicherzustellen, dass das Objekt korrekt initialisiert wird.

3.. Klassenbeziehungen verstehen: Vererbung und Aggregation

Bei objektorientiertem Design ist es entscheidend, die Beziehungen zwischen Klassen ordnungsgemäß aufzubauen. Die beiden gemeinsamen Beziehungen sind Vererbung und Aggregation (Aggregation/Zusammensetzung).

3.1 Vererbung: "IS-A" -Beziehung

Vererbung bedeutet, dass eine Klasse eine besondere Art einer anderen Klasse ist. Zum Beispiel "Hund ist ein Tier", dann kann die Hundeklasse die Tierklasse erben. Die Vererbung wird über das Keyword erweitert.

• Merkmale: Unterklassen erben die öffentlichen und geschützten Eigenschaften und Methoden der übergeordneten Klasse. Unterklassen können die Methoden der übergeordneten Klasse überschreiben oder ihre eigenen neuen Eigenschaften und Methoden hinzufügen.
• Anwendbares Szenario: Wenn eine Unterklasse tatsächlich eine spezifischere Implementierung der übergeordneten Klasse ist.

Im ursprünglichen Code erweitert die Klinik Patienten mit "Die Klinik ist eine Art Patient". Dies entspricht offensichtlich nicht der Reality -Logik. Eine Klinik ist kein Patient, sondern eine Einheit, die Patienten verwaltet. Daher ist diese Erbschaftsbeziehung unangemessen.

3.2 Aggregation/Zusammensetzung: "Has-a" -Beziehung

Aggregation bedeutet, dass eine Klasse eine Instanz einer anderen Klasse als Mitglied enthält. Zum Beispiel "Die Klinik besitzt den Patienten", enthält die Klinikklasse eine Sammlung eines oder mehrerer Patientenobjekte. Die Aggregation wird implementiert, indem eine Instanz einer anderen Klasse als Eigenschaft in einer Klasse deklariert wird.

• Merkmale: Eine Klasse dient als integraler Bestandteil einer anderen. Die eingeschlossenen Klassen existieren unabhängig und können auch von anderen Klassen verwendet werden.
• Anwendbares Szenario: Wenn eine Klasse die Funktionen oder Daten einer anderen Klasse verwenden muss und es eine eigene "eigene" Beziehung zwischen ihnen gibt.

Für die Beziehung zwischen Klinik und Patient ist ein vernünftigeres Modell die Aggregation: Ein Klinikobjekt "besitzt" eine Sammlung von einem oder mehreren Patientenobjekten. Daher sollte die Klinikklasse den Patienten nicht erben, sondern eine Reihe von Patientenobjekten darin aufrechterhalten.

Basierend darauf können wir die Klinikklasse neu gestalten, unnötige Vererbung entfernen und es ermöglichen, das Patientenobjekt über eine Aggregationsbeziehung zu verwalten:

  Php
Klinik {
    private $ Patienten = []; // Die Klinik hat eine Gruppe von Patienten/**
     * Erhalten Sie eine Liste aller Patienten in der Klinik.
     *
     * @return Array mit Patientenobjekten*/
    öffentliche Funktion getPatients () {
        kehren $ this-> Patienten zurück;
    }

    /**
     * Fügen Sie der Klinik einen neuen Patienten hinzu.
     *
     * @param String $ Name Patientenname* @param int $ Alter Patienten Alter* @param String $ Gender Patient Geschlecht*/
    öffentliche Funktion ordnungsgemäß ($ name, $ ay, $ Gender) {
        // Die Patientenliste mit dem korrekt initialisierten Patientenobjekt $ this-> Patienten [] = neuer Patient ($ Name, $ ay, $ Gender) hinzufügen;
    }

    /**
     * Entfernen Sie einen Patienten aus der Klinik basierend auf dem Index.
     *
     * @param int $ index, um den Index des Patienten zu löschen*/
    öffentliche Funktion DeletePatient ($ index) {
        if (isset ($ this-> Patienten [$ index])) {
            nicht fest ($ this-> Patienten [$ index]);
            // Setzen Sie den Array-Index zurück, um Hohlräume zu vermeiden, optionale Operation $ this-> Patienten = array_values ​​($ this-> Patienten);
        }
    }
}
?>

4. Komplette Beispielcode und führen Sie die Ergebnisse aus

Kombinieren Sie die oben genannten Korrekturen mit dem Konstruktor der Patientenklasse und Anpassungen an der Aggregationsbeziehung der Klinikklasse. Folgendes ist ein vollständiges Beispiel für den Optimierungscode:

  Php
// Patientenklasse Definitionsklasse Patient {
    privat $ name;
    privates Alter;
    privates $ Gender;

    Öffentliche Funktion __construct ($ name, $ ay, $ Gender) {
        $ this-> name = $ name;
        $ this-> Alter = $ Alter;
        $ this-> Gender = $ Gender;
    }

    öffentliche Funktion getName () {
        $ this-> name zurück;
    }

    öffentliche Funktion getage () {
        $ this-> Alter zurückgeben;
    }

    öffentliche Funktion getGender () {
        Rückgabe $ this-> Geschlecht;
    }
}

// Klinikklinik für Klinikklassen {
    private $ Patienten = [];

    öffentliche Funktion getPatients () {
        kehren $ this-> Patienten zurück;
    }

    öffentliche Funktion ordnungsgemäß ($ name, $ ay, $ Gender) {
        $ this-> Patienten [] = neuer Patient ($ name, $ ay, $ Gender);
    }

    öffentliche Funktion DeletePatient ($ index) {
        if (isset ($ this-> Patienten [$ index])) {
            nicht fest ($ this-> Patienten [$ index]);
            // Optional: REINDEX Das Array, um die Schlüssel aufeinanderfolgend $ this-> patienten = array_values ​​($ this-> Patienten) zu machen;
        }
    }
}

// instanziieren und betreiben $ Clinic = New Clinic ();

$ klinik-> ordnungsgemäß ("Patrick Star", 18, "männlich");
$ klinik-> ordnungsgemäß ("SpongeBob Squarepants", 17, "männlich");
$ klinik-> ordnungsgemäß ("Eugene Krab", 28, "männlich");

echo "Erste Patientenliste: \ n";
print_r ($ klinik-> getPatients ());

$ Clinic-> DeletePatient (1); // den Patienten mit Index 1 löschen (SpongeBob -Quadratiker)

echo "\ npatient liste nach lösch: \ n";
print_r ($ klinik-> getPatients ());

?>

Erwartete Ausgabe:

 Erste Patientenliste:
Array
(
    [0] => Patientenobjekt
        (
            [Name: Patient: privat] => Patrick Star
            [Alter: Patient: Privat] => 18
            [Geschlecht: Patient: Privat] => Männlich
        )

    [1] => Patientenobjekt
        (
            [Name: Patient: privat] => SpongeBob Quadrepants
            [Alter: Patient: Privat] => 17
            [Geschlecht: Patient: Privat] => Männlich
        )

    [2] => Patientenobjekt
        (
            [Name: Patient: Privat] => Eugene Krab
            [Alter: Patient: Privat] => 28
            [Geschlecht: Patient: Privat] => Männlich
        )

)

Patientenliste nach dem Löschen:
Array
(
    [0] => Patientenobjekt
        (
            [Name: Patient: privat] => Patrick Star
            [Alter: Patient: Privat] => 18
            [Geschlecht: Patient: Privat] => Männlich
        )

    [1] => Patientenobjekt
        (
            [Name: Patient: Privat] => Eugene Krab
            [Alter: Patient: Privat] => 28
            [Geschlecht: Patient: Privat] => Männlich
        )

)

Wie aus der Ausgabe ersichtlich ist, wird das Patientenobjekt jetzt korrekt initialisiert, und die Klinikklasse kann die Patientenliste effektiv verwalten, ohne dass Nullwerte angezeigt werden.

5. Vorsichtsmaßnahmen und Best Practices

• Verwenden Sie immer __Construct, um Objekte zu initialisieren: Entwickeln Sie die Gewohnheit, die __construct -Methode in Klassen zu definieren, die Eigenschaften initialisieren müssen, und stellen Sie sicher, dass sich das Objekt bei der Erstellung in einem gültigen Zustand befindet.
• Bewerten Sie die Beziehung zwischen den Klassen sorgfältig: Denken Sie beim Entwerfen von Kursen unbedingt über die tatsächliche Beziehung zwischen ihnen nach. Ist es "is-a" (Erbschaft) oder "Has-a" (Aggregation/Kombination)? Falsche Klassenbeziehungen können zu Designfehler führen und den Code schwer zu pflegen und zu verstehen.
• Missbrauch der Erbschaft: Die Vererbung ist eine starke Kopplungsbeziehung und sollte mit Vorsicht verwendet werden. Die Vererbung wird nur berücksichtigt, wenn die Unterklasse tatsächlich eine spezielle Version der übergeordneten Klasse ist. Überbeanspruchung der Vererbung kann zu "fragilen Basisklassenproblemen" und komplexen Klassenhierarchien führen.
• Flexibilität der Aggregation: Die Aggregation (oder eine stärkere Kombination) bietet eine größere Flexibilität und ermöglicht es, zur Laufzeit dynamisch hinzugefügt oder entfernt werden, ohne Eltern-Kind-Beziehungen zu erzwingen.
• Einkapselungsprinzip: Attribute privat (privat oder geschützt) und auf sie durch öffentliche Getter/Setter -Methoden zugreifen und diese ändern, ist eine gute Kapselungspraxis.
• Lesbarkeit und Wartung der Code: Klare und logisch vernünftige Klassengestaltung kann die Lesbarkeit des Codes und die zukünftige Wartbarkeit erheblich verbessern.

Das obige ist der detaillierte Inhalt vonPHP-objektorientierte Programmierung: Lösen Sie die Nullwertprobleme in der Vererbung und das richtige Design von Klassenbeziehungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!