Bei der objektorientierten Programmierung (englisch: Object-Oriented Programming, Abkürzung: OOP) ist ein Objekt ein Ganzes, das aus Informationen und einer Beschreibung der Verarbeitung dieser Informationen besteht und eine Abstraktion der realen Welt darstellt.
In der realen Welt sind die Dinge, mit denen wir konfrontiert sind, Objekte wie Computer, Fernseher, Fahrräder usw.
Es gibt drei Hauptmerkmale von Objekten:
Das Verhalten des Objekts: Welche Operationen auf das Objekt angewendet werden können, das Einschalten des Lichts und das Ausschalten des Lichts sind Verhaltensweisen.
Die Form des Objekts: wie das Objekt reagiert, wenn diese Methoden angewendet werden, Farbe, Größe, Aussehen.
Darstellung von Objekten: Die Darstellung von Objekten entspricht einem Ausweis, der speziell die Unterschiede im gleichen Verhalten und Status unterscheidet.
Beispielsweise ist „Tier“ eine abstrakte Klasse, und Hunde und Schafe sind konkrete Objekte. Sie können geschrieben werden, können laufen und andere Verhaltenszustände aufweisen.
Klasse – definiert die abstrakten Eigenschaften einer Sache. Die Definition einer Klasse umfasst die Form der Daten und die Operationen an den Daten.
Object - ist eine Instanz einer Klasse.
Mitgliedsvariablen – Variablen, die innerhalb einer Klasse definiert sind. Der Wert dieser Variablen ist für die Außenwelt unsichtbar, kann aber über Mitgliedsfunktionen abgerufen werden. Nachdem die Klasse als Objekt instanziiert wurde, kann die Variable als Attribut des Objekts bezeichnet werden.
Mitgliedsfunktionen werden innerhalb der Klasse definiert und können für den Zugriff auf die Daten des Objekts verwendet werden.
Vererbung – Vererbung ist ein Mechanismus, durch den Unterklassen automatisch die Datenstrukturen und Methoden ihrer übergeordneten Klasse teilen. Dies ist eine Beziehung zwischen Klassen. Wenn Sie eine Klasse definieren und implementieren, können Sie dies auf der Grundlage einer vorhandenen Klasse tun, den von der vorhandenen Klasse definierten Inhalt als Ihren eigenen Inhalt übernehmen und einige neue Inhalte hinzufügen.
Parent class – Eine Klasse, die von anderen Klassen geerbt wird, kann als übergeordnete Klasse, Basisklasse oder Superklasse bezeichnet werden.
Subclass - Eine Klasse, die von anderen Klassen erbt, wird als Unterklasse bezeichnet oder kann auch als abgeleitete Klasse bezeichnet werden.
Polymorphismus – Polymorphismus bedeutet, dass dieselbe Funktion oder Methode auf mehrere Objekttypen angewendet werden kann und unterschiedliche Ergebnisse erzielt. Verschiedene Objekte können beim Empfang derselben Nachricht unterschiedliche Ergebnisse liefern. Dieses Phänomen wird als Polymorphismus bezeichnet.
Overloading - Einfach ausgedrückt handelt es sich um eine Situation, in der Funktionen oder Methoden denselben Namen, aber unterschiedliche Parameterlisten haben. Solche Funktionen oder Methoden mit demselben Namen und unterschiedlichen Parametern werden als überladene Funktionen oder Methoden bezeichnet.
Abstraktion – Abstraktion bezieht sich auf die Abstraktion von Objekten mit konsistenten Datenstrukturen (Attributen) und Verhaltensweisen (Operationen) in Klassen. Eine Klasse ist eine Abstraktion, die wichtige Eigenschaften einer Anwendung widerspiegelt und andere irrelevante Inhalte ignoriert. Die Einteilung einer Klasse ist subjektiv, muss sich jedoch auf die konkrete Anwendung beziehen.
Kapselung – Kapselung bezieht sich auf das Zusammenfassen der Eigenschaften und des Verhaltens eines Objekts, das in der realen Welt existiert, und auf die Einordnung in eine logische Einheit.
Constructor - wird hauptsächlich zum Initialisieren des Objekts beim Erstellen des Objekts verwendet, dh zum Zuweisen von Anfangswerten zu den Objektmitgliedsvariablen. Er wird immer zusammen mit dem neuen Operator in der Anweisung zum Erstellen des Objekts verwendet.
Destructor - Destruktor (Destruktor) Im Gegensatz zum Konstruktor führt das System den Destruktor automatisch aus, wenn das Objekt seinen Lebenszyklus beendet (z. B. wenn die Funktion, in der sich das Objekt befindet, aufgerufen wurde). Destruktoren werden oft verwendet, um „Aufräumarbeiten“ durchzuführen (wenn Sie beispielsweise ein Objekt erstellen, verwenden Sie new, um einen Speicherplatz zu öffnen, der vor dem Beenden mit delete im Destruktor freigegeben werden sollte).
In der Abbildung unten haben wir drei Objekte über die Klasse „Auto“ erstellt: Mercedes, BMW und Audi.
$mercedes = neues Auto ();$bmw = neues Auto ();$audi = neues Auto ();
Das übliche Syntaxformat für PHP-Definitionsklassen ist wie folgt:
<?phpclass phpClass { var $var1; var $var2 = "constant string"; function myfunc ($arg1, $arg2) { [..] } [..]}?>Die Analyse lautet wie folgt:
Klassen werden mit dem Schlüsselwort class gefolgt vom Klassennamen definiert.
Variablen und Methoden können in einem Paar geschweifter Klammern ({}) nach dem Klassennamen definiert werden.
Klassenvariablen werden mit var deklariert und Variablen können auch initialisiert werden.
Funktionsdefinitionen ähneln PHP-Funktionsdefinitionen, der Zugriff auf Funktionen ist jedoch nur über die Klasse und die von ihr instanziierten Objekte möglich.
<?phpclass Site { /* Mitgliedsvariablen*/ var $url; var $title; /* Mitgliedsfunktionen*/ function setUrl($par){ $this->url = $par } function getUrl(){ echo $this ->url . PHP_EOL; } function setTitle($par){ $this->title = $par } function getTitle(){ echo $this->title . }}?>Die Variable $this repräsentiert ein eigenes Objekt.
PHP_EOL ist das Newline-Zeichen.
Nachdem eine Klasse erstellt wurde, können wir den neuen Operator verwenden, um Objekte dieser Klasse zu instanziieren:
$codercto = neue Site;$taobao = neue Site;$google = neue Site;
Im obigen Code haben wir drei Objekte erstellt. Als nächstes schauen wir uns an, wie man auf Mitgliedsmethoden und Mitgliedsvariablen zugreift.
Nachdem wir ein Objekt instanziiert haben, können wir das Objekt zum Aufrufen von Mitgliedsmethoden verwenden. Die Mitgliedsmethoden des Objekts können nur mit den Mitgliedsvariablen des Objekts arbeiten:
// Rufen Sie die Member-Funktion auf, um den Titel und die URL festzulegen $codercto->setTitle( "Coder Tutorial" );$taobao->setTitle( "Taobao" );$google->setTitle( "Google Search" );$codercto- > setUrl( 'www.codercto.com' );$taobao->setUrl( 'www.taobao.com' );$google->setUrl( 'www.google.com' );// Rufen Sie die Mitgliedsfunktion auf, um den Titel und die URL abzurufen $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao-> getUrl( );$google->getUrl();
Der vollständige Code lautet wie folgt:
<?php class Site { /* Member-Variablen */ var $ title ; /* Member-Funktionen */ function setUrl ( $par ) { $this -> url = $par } function getUrl (){ echo $ this -> url ; } function setTitle ( $par ){ $this - > title = $ par ; function getTitle () { echo $this -> title ; }} $ codercto = new Site ; $ google = new Site ; // Member - Funktion aufrufen , Titel und URL festlegen ( " Coder Tutorial " ) ; " ); $google -> setTitle ( "Google Search" ); $codercto -> setUrl ( 'www.codercto.com' ); $taobao -> setUrl ( 'www.taobao.com' ); $google -> setUrl ( 'www.google.com' ); // Rufen Sie die Member-Funktion auf, um den Titel und die URL zu erhalten $ codercto -> getTitle ( ) ; ) ; $ google - > getTitle ( ) ; $ taobao - > getUrl ( ) ;Wenn Sie den obigen Code ausführen, lautet das Ausgabeergebnis:
Code-Farmer-Tutorial Taobao Google-Suche www.codercto.comwww.taobao.comwww.google.com
Der Konstruktor ist eine besondere Art von Methode. Es wird hauptsächlich verwendet, um das Objekt beim Erstellen des Objekts zu initialisieren, dh den Objektmitgliedsvariablen Anfangswerte zuzuweisen und es mit new Operator in der Anweisung zum Erstellen des Objekts zu verwenden.
Mit PHP 5 können Entwickler eine Methode als Konstruktor in einer Klasse mit der folgenden Syntax definieren:
void __construct ([ gemischte $args [, $... ]] )
Im obigen Beispiel können wir die Variablen $url und $title über die Konstruktormethode initialisieren:
function __construct( $par1, $par2 ) { $this->url = $par1;}Jetzt müssen wir die Methoden setTitle und setUrl nicht mehr aufrufen:
$codercto = new Site('www.codercto.com', 'Coder Tutorial');$taobao = new Site('www.taobao.com', 'Taobao');$google = new Site('www.google . com', 'Google-Suche');// Rufen Sie die Member-Funktion auf, um den Titel und die URL abzurufen $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao->getUrl(); $google ->getUrl();Destruktor (Destruktor) Im Gegensatz zum Konstruktor führt das System den Destruktor automatisch aus, wenn das Objekt seinen Lebenszyklus beendet (z. B. wenn die Funktion, in der sich das Objekt befindet, aufgerufen wurde).
PHP 5 führte das Konzept der Destruktoren ein, das anderen objektorientierten Sprachen ähnelt. Die Syntax lautet wie folgt:
void __destruct ( void )
<?phpclass MyDestructableClass { function __construct() { print "constructorn"; $this->name = "MyDestructableClass" } function __destruct() { print "destroy" "n"; }$obj = new MyDestructableClass();?>Wenn Sie den obigen Code ausführen, lautet das Ausgabeergebnis:
Der Konstruktor zerstört MyDestructableClass
PHP verwendet das Schlüsselwort „extends“, um eine Klasse zu erben. PHP unterstützt keine Mehrfachvererbung. Das Format ist wie folgt:
class Child erweitert Parent { // Codeteil}Im Beispiel erbt die Klasse Child_Site die Klasse Site und erweitert deren Funktionen:
<?php // Untergeordnete Klasse erweitert Site-Kategorie class Child_Site erweitert Site { var $category; function setCate($par){ $this->category = $par } function getCate(){ echo $this->category; }}Wenn die von der übergeordneten Klasse geerbte Methode die Anforderungen der Unterklasse nicht erfüllen kann, kann sie neu geschrieben werden. Dieser Vorgang wird als Methodenüberschreibung oder Methodenumschreiben bezeichnet.
Die Methoden getUrl und getTitle werden im Beispiel überschrieben:
function getUrl() { echo $this->url . return $this->url;} function getTitle(){ echo $this->title ;}Die Zugriffskontrolle von PHP auf Eigenschaften oder Methoden wird durch das voranstellen der Schlüsselwörter public (public), protected (protected) oder private (private) erreicht.
public: Auf öffentliche Klassenmitglieder kann von überall aus zugegriffen werden.
geschützt: Auf geschützte Klassenmitglieder kann von ihr selbst und ihren Unterklassen und übergeordneten Klassen zugegriffen werden.
Privat: Auf private Klassenmitglieder kann nur die Klasse zugreifen, in der sie definiert sind.
Klassenattribute müssen als öffentlich, geschützt oder privat definiert werden. Wenn es mit var definiert ist, gilt es als öffentlich.
<?php/** * Define MyClass */class MyClass{ public $public = 'Public'; protected $protected = 'Protected' = 'Private'; echo $this->protected; echo $this->private; }}$obj = new MyClass();echo $obj->public // Diese Zeile kann normal ausgeführt werden echo $obj->protected; // Diese Zeile erzeugt einen schwerwiegenden Fehler. echo $obj->private; // Diese Zeile erzeugt auch einen schwerwiegenden Fehler. $obj->printHello(); // Ausgabe Public, Protected und Private/** * Define MyClass2 */ class MyClass2 erweitert MyClass{ // Öffentlich und geschützt können neu definiert werden, aber privat, aber nicht geschützt $protected = 'Protected2'; function printHello() { echo $this->public echo $this->protected; echo $this->private; }}$obj2 = new MyClass2();echo $obj2->public; // Diese Zeile kann normal ausgeführt werden echo $obj2->private; definiert $obj2->protected; // Diese Zeile erzeugt einen schwerwiegenden Fehler $obj2->printHello(); // Ausgabe Public, Protected2 und Undefiniert?>Methoden in einer Klasse können als öffentlich, privat oder geschützt definiert werden. Wenn diese Schlüsselwörter nicht festgelegt sind, ist die Methode standardmäßig öffentlich.
<?php/** * Define MyClass */class MyClass{ // Deklariere eine öffentliche Funktion für einen öffentlichen Konstruktor __construct() { } // Deklariere eine öffentliche Funktion für eine öffentliche Methode MyPublic() { } // Deklariere eine geschützte Funktion für eine geschützte Methode MyProtected( ) { } // Eine private Methode deklarieren private function MyPrivate() { } // Diese Methode ist eine öffentliche Funktion Foo() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); }}$myclass = new MyClass;$myclass->MyPublic(); // Diese Zeile kann normal ausgeführt werden $myclass->MyProtected(); Diese Zeile erzeugt einen schwerwiegenden Fehler $myclass->MyPrivate(); // Diese Zeile erzeugt einen schwerwiegenden Fehler $myclass->Foo(); // Public, protected und private können alle ausgeführt werden/** * Define MyClass2 */class MyClass2 erweitert MyClass{ // Diese Methode ist eine öffentliche Funktion Foo2() { $this->MyProtected(); $this->MyPrivate(); Einen schwerwiegenden Fehler erzeugen}}$myclass2 = new MyClass2;$myclass2->MyPublic(); // Diese Zeile kann normal ausgeführt werden $myclass2->Foo2(); Sowohl öffentliche als auch geschützte können ausgeführt werden, private jedoch nicht. :testPublicn"; } private function testPrivate() { echo "Bar::testPrivaten"; }}class Foo erweitert Bar { public function testPublic() { echo "Foo::testPublicn"; } private function testPrivate() { echo "Foo::testPrivaten"; $myFoo = new foo();$myFoo->test(); // Foo::testPublic?>Mithilfe einer Schnittstelle können Sie angeben, welche Methoden eine Klasse implementieren muss, Sie müssen jedoch nicht den spezifischen Inhalt dieser Methoden definieren.
Eine Schnittstelle wird über das Schlüsselwort interface definiert, genau wie die Definition einer Standardklasse, aber alle darin definierten Methoden sind leer.
Alle in einer Schnittstelle definierten Methoden müssen öffentlich sein. Dies ist eine Eigenschaft von Schnittstellen.
Um eine Schnittstelle zu implementieren, verwenden Sie den Implements -Operator. Die Klasse muss alle in der Schnittstelle definierten Methoden implementieren, andernfalls wird ein schwerwiegender Fehler gemeldet. Eine Klasse kann mehrere Schnittstellen implementieren. Verwenden Sie Kommas, um die Namen mehrerer Schnittstellen zu trennen.
<?php// Deklarieren Sie eine 'iTemplate'-Schnittstelle interface iTemplate{ public function setVariable($name, $var); public function getHtml($template);}// Implementieren Sie die Schnittstellenklasse Template implementiert iTemplate{ private $vars = array( ) ; öffentliche Funktion setVariable($name, $var) { $this->vars[$name] = $var } öffentliche Funktion getHtml($template) { foreach($this->vars as $name => $value) { $template = str_replace('{' . $name . '}', $value, $template }}Werte, die innerhalb einer Klasse unverändert bleiben, können als Konstanten definiert werden. Beim Definieren und Verwenden von Konstanten ist die Verwendung des $-Symbols nicht erforderlich.
Der Wert einer Konstante muss ein fester Wert sein und darf keine Variable, kein Klassenattribut, das Ergebnis einer mathematischen Operation oder ein Funktionsaufruf sein.
Seit PHP 5.3.0 können Klassen dynamisch über eine Variable aufgerufen werden. Der Wert dieser Variablen darf jedoch kein Schlüsselwort sein (z. B. self, parent oder static).
<?phpclass MyClass{ const konstant = 'konstanter Wert'; Funktion showConstant() { echo self::constant }}echo MyClass::constant . PHP_EOL; // Seit 5.3.0 $class = neu MyClass();$class->showConstant();echo $class::constant . // Seit PHP 5.3.0?>Jede Klasse muss als abstrakt deklariert werden, wenn mindestens eine Methode darin als abstrakt deklariert ist.
Als abstrakt definierte Klassen können nicht instanziiert werden.
Eine als abstrakt definierte Methode deklariert nur ihre aufrufende Methode (Parameter) und kann nicht ihre spezifische Funktionsimplementierung definieren.
Beim Erben einer abstrakten Klasse muss die Unterklasse alle abstrakten Methoden in der übergeordneten Klasse definieren. Darüber hinaus muss die Zugriffskontrolle dieser Methoden dieselbe (oder entspannter) sein wie in der übergeordneten Klasse. Wenn beispielsweise eine abstrakte Methode als geschützt deklariert ist, sollte die in der Unterklasse implementierte Methode als geschützt oder öffentlich deklariert werden und kann nicht als privat definiert werden.
<?phpabstract class AbstractClass{ // Obligatorisch für Unterklassen, um diese Methoden zu definieren abstract protected function getValue(); abstract protected function prefixValue($prefix); // Gewöhnliche Methode (nicht abstrakte Methode) public function printOut() { print $this - >getValue() . PHP_EOL; }}class ConcreteClass{ protected function getValue() { return "ConcreteClass1"; prefixValue($prefix) { return "{$prefix}ConcreteClass1"; }class ConcreteClass2 erweitert AbstractClass{ public function getValue() { return "ConcreteClass2"; } public function prefixValue($prefix) { return "{$prefix}ConcreteClass2" ; }}$class1 = new ConcreteClass1;$class1->printOut();echo $class1->prefixValue('FOO_') . PHP_EOL;$class2 = new ConcreteClass2;$class2->printOut();echo $class2->prefixValue('FOO_')Wenn Sie den obigen Code ausführen, lautet das Ausgabeergebnis:
ConcreteClass1FOO_ConcreteClass1ConcreteClass2FOO_ConcreteClass2
Darüber hinaus können Methoden der untergeordneten Klasse optionale Parameter enthalten, die in der abstrakten Methode der übergeordneten Klasse nicht vorhanden sind.
Wenn beispielsweise eine Unterklasse einen optionalen Parameter definiert, der nicht in der Deklaration der abstrakten Methode der übergeordneten Klasse enthalten ist, kann sie weiterhin normal ausgeführt werden.
<?phpabstract class AbstractClass{ // Unsere abstrakte Methode muss nur die erforderlichen Parameter definieren abstract protected function prefixName($name);}class ConcreteClass erweitert AbstractClass{ // Unsere Unterklasse kann optionale Optionen definieren, die in der Signatur der übergeordneten Klasse nicht vorhanden sind Parameter öffentliche Funktion prefixName($name, $separator = ".") { if ($name == "Pacman") { $prefix = "Mr" } elseif ($name == "Pacwoman") { $prefix = "Mrs"; } else { $prefix = ""; } return "{$prefix}{$separator} {$name}" }}$class = new ConcreteClass;echo $class->prefixName("Pacman "), "n";echo $class->prefixName("Pacwoman"), "n";?>Die Ausgabe ist:
Herr PacmanFrau Pacwoman
Indem Sie ein Klassenattribut oder eine Methode als statisch deklarieren, können Sie direkt darauf zugreifen, ohne die Klasse zu instanziieren.
Auf statische Eigenschaften kann nicht über ein Objekt einer instanziierten Klasse zugegriffen werden (statische Methoden jedoch schon).
Da statische Methoden keinen Aufruf eines Objekts erfordern, ist die Pseudovariable $this in statischen Methoden nicht verfügbar.
Auf statische Eigenschaften können Objekte nicht über den ->-Operator zugreifen.
Seit PHP 5.3.0 können Klassen dynamisch über eine Variable aufgerufen werden. Der Wert dieser Variablen darf jedoch nicht die Schlüsselwörter self, parent oder static sein.
<?phpclass Foo { public static $my_static = 'foo'; public function staticValue() { return self::$my_static }}print Foo::$my_static . >staticValue() .PHP_EOL;?>Wenn Sie das obige Programm ausführen, lautet das Ausgabeergebnis:
foofoo
PHP 5 fügt ein neues finales Schlüsselwort hinzu. Wenn eine Methode in der übergeordneten Klasse als endgültig deklariert wird, kann die untergeordnete Klasse die Methode nicht überschreiben. Wenn eine Klasse als final deklariert ist, kann sie nicht vererbt werden.
Beim Ausführen des folgenden Codes wird ein Fehler gemeldet:
<?phpclass BaseClass { öffentliche Funktion test() { echo "BaseClass::test() aufgerufen" } final public function moreTesting() { echo "BaseClass::moreTesting() aufgerufen" BaseClass { public function moreTesting() { echo "ChildClass::moreTesting() aufgerufen" }}// Fehlermeldung Schwerwiegender Fehler: Die endgültige Methode BaseClass::moreTesting()?> kann nicht überschrieben werdenPHP ruft den Konstruktor der übergeordneten Klasse nicht automatisch im Konstruktor der untergeordneten Klasse auf. Um den Konstruktor der übergeordneten Klasse auszuführen, müssen Sie parent::__construct() im Konstruktor der untergeordneten Klasse aufrufen.
<?phpclass BaseClass { function __construct() { print "Konstruktormethode in der BaseClass-Klasse" }}class SubClass erweitert BaseClass { function __construct() { parent::__construct(); Die Konstruktormethode der Klasse print „Konstruktormethode in der SubClass-Klasse“ }}class OtherSubClass erweitert BaseClass { // Erben Sie die Konstruktormethode von BaseClass}// Rufen Sie den BaseClass-Konstruktor auf $obj = new BaseClass(); // Rufen Sie die BaseClass- und SubClass-Konstruktoren auf $obj = new SubClass(); // Rufen Sie den BaseClass-Konstruktor auf $obj = new OtherSubClass();?>Wenn Sie das obige Programm ausführen, lautet das Ausgabeergebnis:
Konstruktormethode in der BaseClass-Klasse. Konstruktormethode in der Klasse SubClass. Konstruktormethode in der BaseClass-Klasse