PHP-objektorientierte Programmierung: korrekte Verwendung von Konstruktoren und Unterscheidung zwischen Vererbung und Kombination

Bei der programmorientierten PHP-Objekt-orientierte Programmierung ist dies normalerweise der Fall, wenn der Konstruktor nicht korrekt definiert ist oder die Vererbungsbeziehung falsch verwendet wird. In diesem Artikel wird eingehend untersucht, wie die __construct-Methode zur korrekten Initialisierung eines Objekts verwendet wird und die Beziehung zwischen "IS-A" (Vererbung) und "HAS-A" (Kombination) analysiert wird, wodurch ein unsachgemäßes Klassenentwurf vermieden wird, um sicherzustellen, dass Objekteigenschaften korrekt zugewiesen und zugegriffen werden können.

1. Verstehen Sie den Konstruktor in PHP __construct

In PHP ist der Konstruktor eine spezielle Methode, die automatisch aufgerufen wird, wenn ein neues Objekt erstellt wird (über das neue Schlüsselwort). Die Hauptfunktion des Konstruktors besteht darin, die Eigenschaften des Objekts zu initialisieren und sicherzustellen, dass sich das Objekt in einem gültigen Zustand befindet, bevor es verwendet wird. Der Standardname der Konstruktoren in PHP lautet __construct ().

Ursprüngliche Code -Problemanalyse: Im angegebenen ursprünglichen Code definiert die Patientenklasse eine Methode, die als Datensatz auf dem Namen Patientinformationen festgelegt wird:

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

    öffentliche Funktionsdatensatz ($ name, $ ay, $ gender) {// Dies ist eine normale Methode $ this-> name = $ name;
        $ this-> Alter = $ Alter;
        $ this-> Gender = $ Gender;
    }   
    // ... Getter -Methoden
}

In der Misstrikationsmethode der Klinikklasse wird jedoch der neue Patient ($ name, $ ay, $ Gender) zum Erstellen des Patientenobjekts verwendet:

 Klassenklinik erweitert den Patienten {
    // ...
    öffentliche Funktion ordnungsgemäß ($ name, $ ay, $ Gender) {
        $ this-> Patienten [] = neuer Patient ($ name, $ ay, $ Gender); // Versuchen Sie, Parameter über den Konstruktor zu übergeben}
    // ...
}

Wenn ein neuer Patient ($ name, $ ay, $ Gender) aufgerufen wird, wird PHP versuchen, den Konstruktor der Patientenklasse __konstruct zu finden, um diese Parameter zu erhalten. Da __construct in der Patientenklasse nicht definiert ist, werden diese Parameter nicht an eine Methode zur Initialisierung der Eigenschaften übergeben, was dazu führt, dass die $ -Age- und $ -Gender -Eigenschaften des neu erstellten Patienten des Patienten nicht initialisiert werden, was Null ist.

Lösung: Umbenennen Sie __construct die Datensatzmethode in der Patientenklasse in __construction, um sie zu einem echten Konstruktor zu machen.

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

    Öffentliche Funktion __construct ($ name, $ ay, $ Gender) {// Correct Constructor $ 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;
    }
}

Auf diese Weise wird die __construct -Methode automatisch aufgerufen und der Name $ ay, $ Geschlechtsattribute werden korrekt initialisiert, wenn der neue Patient ("Patrick Star", 18, "männlich") ausgeführt wird.

2. Unterscheiden Sie zwischen Erbschaft und Zusammensetzung

Zwei Kernkonzepte im objektorientierten Design sind Vererbung und Zusammensetzung. Die richtige Auswahl ist für den Aufbau eines robusten, wartbaren Codes von entscheidender Bedeutung.

• Vererbungsbeziehung - "IS -A" -Beziehung: Verwenden Sie die Vererbung, wenn eine Klasse (Unterklasse) eine spezielle Art einer anderen Klasse (übergeordnete Klasse) ist. Zum Beispiel erweitert der Hund ein Tier (ein Hund ist ein Tier). Eine Unterklasse erbt alle öffentlichen und geschützten Eigenschaften und Methoden der Elternklasse.

• Komposition - "Has -a" -Beziehung: Verwenden Sie die Kombination, wenn eine Klasse eine Instanz einer anderen Klasse als Attribut enthält. Zum Beispiel hat das Auto einen Motor (das Auto hat einen Motor). Dies bedeutet, dass ein Objekt aus anderen Objekten besteht.

Analyse des ursprünglichen Codeproblems: Im Originalcode erbt die Klinikklasse die Patientenklasse: Klassenklinik erweitert den Patienten. Aus einer Geschäftslogik ist eine Klinik (Klinik) kein Patient (Patient). Die Klinik sollte den Patienten haben oder verwalten , nicht einen Patienten. Diese fehlerhafte Anwendung der Beziehung "IS-A" führt zu Verwirrung im Klassendesign. Das $ Patienten-Array ist in der Klinikklasse definiert, um das Patientenobjekt zu speichern, was selbst darauf hinweist, dass die Beziehung zwischen Klinik und Patient "HAS-A" ist.

Lösung: Das Entfernen einer unsachgemäßen Erbschaftsklinikklasse sollte die Patientenklasse nicht erben. Es sollte eine Sammlung von Patientenobjekten durch die Kombination beibehalten.

  Php
// ... Patientenklasse (wie oben korrigiert) ...

Klassenklinik {// erben den Patienten nicht mehr
    private $ Patienten = []; // Clinic hat eine Patientenliste öffentliche Funktion getPatients () {
        kehren $ this-> Patienten zurück;
    }

    öffentliche Funktion ordnungsgemäß ($ name, $ ay, $ Gender) {
        // Durch die Kombination erstellt und verwaltet die Klinik das Patientenobjekt $ this-> Patienten [] = neuer Patient ($ name, $ ay, $ Gender); 
    }

    öffentliche Funktion DeletePatient ($ index) {
        nicht fest ($ this-> Patienten [$ index]);
        // Das Array neu index, um leere Räume zu vermeiden, optional, aber empfohlen $ this-> patienten = array_values ​​($ this-> Patienten); 
    }
}

3..

Das Kombinieren der beiden oben genannten Korrekturen ist Folgendes ist der optimierte PHP -Code:

  Php
Klassenpatient {
    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;
    }
}

Klinik {
    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) {
        nicht fest ($ this-> Patienten [$ index]);
        // Das Array neu indeminieren, um Kontinuität zu gewährleisten und Unfälle in nachfolgenden Operationen zu vermeiden $ this-> patienten = array_values ​​($ this-> Patienten);
    }
}

// Instanziierung und testen Sie $ Clinic = New Clinic ();

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

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

print_r ($ klinik-> getPatients ());
?>

Codeausgabe:

 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, werden die Eigenschaften des Patientenobjekts korrekt initialisiert, und das Klinikobjekt verwaltet nun korrekt eine Sammlung von Patientenobjekten. Nach dem löschlichen Betrieb wird das Array ebenfalls wieder integriert.

4. Vorsichtsmaßnahmen und Best Practices

• Erläutern Sie die Rolle des Konstruktors: Verwenden Sie immer das __construct -Verfahren, um den Grundzustand des Objekts zu initialisieren. Wenn das Objekt erstellt wird, stellen Sie sicher, dass __Construct diese Parameter empfangen und verarbeiten kann.
• Wählen Sie die richtige Klassenbeziehung: Überlegen Sie beim Entwerfen von Kursen sorgfältig, ob ihre Beziehung "is-a" (Erbschaft) oder "HAS-A" (Kombination) ist. Falsche Klassenbeziehungen können zu unnötiger Komplexität, schwer zu machenden Code und potenziellen logischen Fehlern führen. Im Allgemeinen sind Kombinationen flexibler als Vererbung und empfohlener.
• Zugriff auf private Attribute: Nachdem das Attribut privat erklärt wurde, kann nur innerhalb der Klasse zugegriffen werden. Wenn Sie diese Attributwerte extern erhalten müssen, müssen Sie eine öffentliche Getter -Methode bereitstellen (z. B. getName ()).
• Reindedex nach Array -Operation: Wenn nicht festgelegte Elemente aus dem Array aus dem Array sind, sind die Schlüssel des Arrays möglicherweise nicht mehr kontinuierlich. Wenn nachfolgende Operationen auf kontinuierlichen numerischen Indizes beruhen, sollten sie unter Verwendung von Funktionen wie Array_Values ​​() wie $ this-> patients = array_values ​​($ this-> Patienten) wieder integriert werden.

Durch die Befolgung dieser Prinzipien können Null-Value-Ausgangsprobleme, die bei der programmorientierten PHP-Programmierung üblich sind, effektiv vermieden werden, und Anwendungen, die klarer, robust und leicht zu warten, können gebaut werden.

Das obige ist der detaillierte Inhalt vonPHP-objektorientierte Programmierung: korrekte Verwendung von Konstruktoren und Unterscheidung zwischen Vererbung und Kombination. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!