In PHP OOP bezieht sich Self :: auf die aktuelle Klasse, Eltern :: Bezieht sich auf die Elternklasse, static :: wird für die sp?te statische Bindung verwendet. 1. Self :: wird für statische Methoden und st?ndige Aufrufe verwendet, unterstützt jedoch keine sp?te statische Bindung. 2. Eltern :: wird für Unterklassen verwendet, um übergeordnete Klassenmethoden aufzurufen, und auf private Methoden k?nnen nicht zugegriffen werden. 3. Static :: unterstützt die sp?te statische Bindung, geeignet für Vererbung und Polymorphismus, kann jedoch die Code -Lesbarkeit beeinflussen.

Einführung

In der programmorientierten PHP (OOP) ist es entscheidend, den Unterschied zwischen self:: , parent:: und static:: zu verstehen. Diese Schlüsselw?rter spielen unterschiedliche Rollen, wenn Sie mit Klassen und Objekten zu tun haben, und das Beherrschen kann Ihnen helfen, Code effizienter zu schreiben und zu verwalten. Wenn Sie diesen Artikel lesen, lernen Sie, wie Sie diese Schlüsselw?rter in verschiedenen Szenarien korrekt verwenden und die Prinzipien und Best Practices dahinter verstehen.

überprüfung des Grundwissens

Bevor Sie sich mit diesen Schlüsselw?rtern befassen, überprüfen wir einige der grundlegenden Konzepte von PHP OOP. Die Klassen und Objekte von PHP sind der Kern von OOP. Klassen definieren eine Reihe von Eigenschaften und Methoden, w?hrend Objekte Instanzen von Klassen sind. In den Klassen müssen wir oft auf die Klasse selbst, die übergeordnete Klasse oder den aktuellen Kontext verweisen, in dem self:: , parent:: und static:: Come ins Spiel.

Kernkonzept oder Funktionsanalyse

Definition und Funktion von self::

self:: Keyword wird verwendet, um auf die aktuelle Klasse selbst zu verweisen. Es wird oft für Aufrufe zu statischen Methoden und Konstanten verwendet. Wenn Sie beispielsweise eine andere statische Methode in einer Klasse aufrufen oder auf eine statische Eigenschaft zugreifen müssen, k?nnen Sie self:: .

 Klasse myclass {
    ?ffentliche statische Funktion myMethod () {
        echo "das ist MyMethod";
    }

    ?ffentliche statische Funktion othermethod () {
        self :: myMethod (); // MyMethod in derselben Klasse rufen
    }
}

Der Vorteil von self:: ist, dass es ausdrücklich die aktuelle Klasse bezieht, was in statischen Kontexten sehr nützlich ist. Seine Einschr?nkung ist jedoch, dass es nicht für sp?te statische Bindungen verwendet werden kann, da es immer auf die Klasse zeigt, die sie definiert, nicht auf die Klasse, die sie nennt.

Definition und Funktion von parent::

parent:: Keyword wird verwendet, um sich auf die übergeordnete Klasse zu beziehen. Es wird in Unterklassen verwendet, um die Methoden der Elternklasse aufzurufen oder auf die Eigenschaften der Elternklasse zuzugreifen. Wenn Sie beispielsweise die Methode der Elternklasse in einer Unterklasse aufrufen m?chten, k?nnen Sie parent:: .

 Klasse Elternklasse {
    ?ffentliche Funktion myMethod () {
        echo "das ist myMethod von Elternklasse";
    }
}

Klasse Child Class erweitert die Elternklasse {
    ?ffentliche Funktion myMethod () {
        Elternteil :: MyMethod (); // rufe die myMethod der übergeordneten Klasse an
        echo "Das ist MyMethod von Child Class";
    }
}

Der Vorteil von parent:: Es ist jedoch zu beachten, dass die Kinderklasse, wenn die Methode der Elternklasse privat ist, nicht mit parent:: darauf zugreifen kann.

Definition und Funktion von static::

static:: Schlüsselwort wird für die sp?te statische Bindung verwendet. Es bezieht sich auf die Klasse, die sie nennt, und nicht auf die Klasse, die sie definiert. Dies macht es bei statischen Methoden sehr nützlich, insbesondere bei Vererbungs- und polymorphen Szenarien.

 Klasse Elternklasse {
    ?ffentliche statische Funktion myMethod () {
        echo "das ist myMethod von Elternklasse";
    }
}

Klasse Child Class erweitert die Elternklasse {
    ?ffentliche statische Funktion myMethod () {
        echo "Das ist MyMethod von Child Class";
    }

    ?ffentliche statische Funktion othermethod () {
        static :: myMethod (); // Der Anruf ist MyMethod of Child Class
    }
}

Der Vorteil von static:: Dies kann jedoch auch zu einer Verringerung der Lesbarkeit und Wartbarkeit des Codes führen, da Aufrufe statischer Kontexte weniger intuitiv sein k?nnen.

Beispiel für die Nutzung

Grundnutzung

Schauen wir uns einige grundlegende Nutzungsbeispiele an:

 Klasse myclass {
    public static $ myproperty = "Hallo, Welt!";

    ?ffentliche statische Funktion myMethod () {
        echo self :: $ myproperty;
    }
}

MyClass :: MyMethod (); // Ausgabe "Hallo, Welt!"

 Klasse Elternklasse {
    ?ffentliche Funktion myMethod () {
        echo "Elternklasse";
    }
}

Klasse Child Class erweitert die Elternklasse {
    ?ffentliche Funktion myMethod () {
        Elternteil :: MyMethod ();
        echo "Kinderklasse";
    }
}

$ child = new ChildClass ();
$ Child-> myMethod (); // Ausgabe "Elternklasse Kinderklasse"

 Klasse Elternklasse {
    ?ffentliche statische Funktion myMethod () {
        echo "Elternklasse";
    }
}

Klasse Child Class erweitert die Elternklasse {
    ?ffentliche statische Funktion myMethod () {
        echo "Kinderklasse";
    }

    ?ffentliche statische Funktion othermethod () {
        static :: myMethod ();
    }
}

Kinderklasse :: AnotherMethod (); // Ausgabe "Kinderklasse"

Erweiterte Verwendung

In komplexeren Szenarien k?nnen diese Schlüsselw?rter Ihnen helfen, eine flexiblere Codestruktur zu erreichen. In Designmustern kann beispielsweise static:: verwendet werden, um Singleton -Muster zu implementieren:

 Klassen Singleton {
    private statische $ Instanz;

    geschützte Funktion __construct () {}

    ?ffentliche statische Funktion getInstance () {
        if (null === static :: $ instance) {
            static :: $ instance = new static ();
        }
        Rückgabe static :: $ Instance;
    }
}

Klasse Concretesingleton erweitert Singleton {}

$ Singleton1 = Concretesingleton :: GetInstance ();
$ Singleton2 = Concretesingleton :: GetInstance ();

var_dump ($ Singleton1 === $ Singleton2); // Ausgabe bool (true)

H?ufige Fehler und Debugging -Tipps

H?ufige Fehler bei der Verwendung dieser Schlüsselw?rter umfassen:

• Bei der Verwendung von self:: dachte es f?lschlicherweise, dass es eine sp?te statische Bindung durchführen würde, was dazu führt, dass die falsche Klassenmethode aufgerufen wird.
• Wenn parent:: in einer Unterklasse, kann vergessen, dass die übergeordnete Klassenmethode privatisiert werden kann, was zu einer Unzug?nglichkeit führt.
• Bei Verwendung von static:: nimmt die Code -Lesbarkeit ab und es ist schwierig, die tats?chlichen Anrufklassen aufzuspüren.

Zu den Methoden zum Debuggen dieser Probleme geh?ren:

• Verwenden Sie das Debugging -Tool der IDE, um den Anrufstack anzuzeigen und die tats?chlichen Anrufklassen und -methoden zu best?tigen.
• Fügen Sie dem Code Protokolle oder Debugginformationen hinzu, um den Ausführungsfluss zu verfolgen.
• Lesen Sie die PHP -Dokumentation sorgf?ltig durch, um das spezifische Verhalten und die Einschr?nkungen dieser Schlüsselw?rter zu verstehen.

Leistungsoptimierung und Best Practices

In Bezug auf die Leistungsoptimierung verursachen self:: und parent:: normalerweise keine signifikanten Leistungsunterschiede, da sie die aufrufende Klasse bereits zur Kompilierungszeit bestimmen. static:: kann jedoch aufgrund der Notwendigkeit einer sp?ten statischen Bindung zur Laufzeit einen leistungsf?higen überkopf haben.

Zu den besten Verfahren geh?ren:

• Versuchen Sie in statischen Kontexten, self:: oder static:: zu verwenden, anstatt direkt Klassennamen zu verwenden, was die Wartbarkeit des Codes verbessern kann.
• Wenn Sie in Unterklassen die übergeordnete Klassenmethode aufrufen müssen, wird parent:: bevorzugt, damit die Absicht explizit ausgedrückt werden kann.
• Verwenden Sie in Entwurfsmustern oder Szenarien, in denen eine versp?tete statische Bindung erforderlich ist, static:: , achten Sie jedoch auf die Lesbarkeit und Wartbarkeit des Codes.

Durch das Verst?ndnis und die Verwendung self:: , parent:: und static:: k?nnen Sie die Essenz von Php OOP besser erfassen und effizienter und leichter schreiben.

Das obige ist der detaillierte Inhalt vonErkl?ren Sie den Unterschied zwischen Selbst ::, Parent :: und static :: in Php OOP.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!