Die Objekte in PHP5 wurden systematischer und umfassender angepasst und ähneln in ihrem aktuellen Erscheinungsbild möglicherweise etwas Java. Dieser Abschnitt konzentriert sich auf den neuen Objektmodus in PHP5 und gibt einige einfachere Beispiele zur Veranschaulichung. Lassen Sie diesen Abschnitt einen neuen Ausgangspunkt für Ihre PHP5-Reise sein. :)
* Konstruktor und Destruktor
* Objektreferenz
*Klon des Objekts
* Private, öffentliche und geschützte Modi in Objekten
* Schnittstellen
* Abstrakte Klasse
* __Anruf
* __set und __get
* Statische Mitglieder
Konstruktor und Destruktor
Wenn in PHP4 eine Funktion denselben Namen wie ein Objekt hat, wird diese Funktion zum Konstruktor des Objekts, und in PHP4 gibt es kein Destruktorkonzept.
In PHP5 heißt der Konstruktor einheitlich __construct, und das Konzept des Destruktors wird eingeführt, der einheitlich __destruct heißt.
Beispiel 1: Konstruktor und Destruktor
Klasse foo {
var $x;
Funktion __construct($x) {
$this->x = $x;
}
Funktion display() {
print($this->x);
}
Funktion __destruct() {
print("bye bye");
}
}
$o1 = neues foo(4);
$o1->display();
?>
Wenn Sie im obigen Beispiel den Aufruf der Klasse foo beenden, wird deren Destruktor aufgerufen und im obigen Beispiel wird „bye bye“ ausgegeben.
Objektreferenzen
in PHP4 durch die Übergabe einer Variablen an eine Funktion oder Methode tatsächlich eine Kopie der Variablen, was bedeutet, dass das, was Sie an die Funktion oder Methode übergeben, eine Kopie der Variablen ist, es sei denn, Sie verwenden eine Referenz . Das Symbol „&“ wird verwendet, um anzugeben, dass eine Referenz erstellt werden soll, keine Kopie. In PHP5 existieren Objekte immer in Form von Referenzen, und Zuweisungsoperationen in Objekten sind ebenfalls Referenzoperationen.
Beispiel 2: Objektreferenz
Klasse foo {
var $x;
Funktion setX($x) {
$this->x = $x;
}
Funktion getX() {
return $this->x;
}
}
$o1 = neues foo;
$o1->setX(4);
$o2 = $o1;
$o1->setX(5);
if($o1->getX() == $o2->getX()) print("Oh mein Gott!");
?>
Klon eines Objekts
Wie oben erwähnt: Wenn ein Objekt immer in Form einer Referenz aufgerufen wird, was soll ich tun, wenn ich eine Kopie des Objekts erhalten möchte? PHP5 bietet eine neue Funktion, nämlich das Klonen von Objekten, und die Syntax lautet __clone.
Beispiel 3: Klonen von Objekten
Klasse foo {
var $x;
Funktion setX($x) {
$this->x = $x;
}
Funktion getX() {
return $this->x;
}
}
$o1 = neues foo;
$o1->setX(4);
$o2 = $o1->__clone();
$o1->setX(5); if($o1->getX() != $o2->getX()) print（"Kopien sind unabhängig"）;
?>
Methoden zum Klonen von Objekten gibt es in vielen anderen Anwendungssprachen, sodass Sie sich keine Sorgen um die Stabilität machen müssen. :) :)
Privater, öffentlicher und geschützter Modus in Objekten
In PHP4 sind alle Methoden und Variablen eines Objekts öffentlich, was bedeutet, dass Sie jede der Variablen und Methoden außerhalb eines Objekts bedienen können. PHP5 führt drei neue Modi zur Steuerung dieser Zugriffsberechtigung ein: Öffentlich, Geschützt und Privat.
Öffentlicher Modus (Public): Ermöglicht die Betriebssteuerung außerhalb des Objekts.
Privater Modus (Private): Nur Methoden innerhalb dieses Objekts dürfen es bedienen und steuern.
Geschützter Modus (Geschützt): Ermöglicht diesem Objekt und seinem übergeordneten Objekt, es zu bedienen und zu steuern.
Beispiel 4: Private, öffentliche und geschützte Modi in Objekten
Klasse foo {
privat $x;
öffentliche Funktion public_foo() {
print("Ich bin öffentlich");
}
geschützte Funktion protected_foo() {
$this->private_foo(); //Ok, da wir in derselben Klasse sind, können wir private Methoden aufrufen
print("Ich bin geschützt");
}
private Funktion private_foo() {
$this->x = 3;
print("Ich bin privat");
}
}
Klasse foo2 erweitert foo {
öffentliche Funktion display() {
$this->protected_foo();
$this->public_foo();
// $this->private_foo(); // Ungültig! Die Funktion ist in der Basisklasse privat
}
} $x = new foo();
$x->public_foo();
//$x->protected_foo(); //Ungültig, geschützte Methoden außerhalb der Klasse und abgeleiteter Klassen können nicht aufgerufen werden
//$x->private_foo(); //Ungültige private Methoden können nur innerhalb der Klasse verwendet werden $x2 = new foo2();
$x2->display();
?>
Tipp: Variablen in Objekten liegen immer in privater Form vor. Eine bessere Möglichkeit besteht darin, die gewünschten Variablen zur Verarbeitung an die Methode eines Objekts zu übergeben.
Schnittstellen
Wie wir alle wissen, unterstützen Objekte in PHP4 die Vererbung. Um ein Objekt zu einer abgeleiteten Klasse eines anderen Objekts zu machen, müssen Sie zur Steuerung einen Code verwenden, der dem von „class foo extensions parent“ ähnelt. In PHP4 und PHP5 kann ein Objekt nur einmal vererbt werden und Mehrfachvererbung wird nicht unterstützt. In PHP5 wurde jedoch ein neuer Begriff geboren: Eine Schnittstelle ist ein spezielles Objekt ohne spezifischen Verarbeitungscode. Es definiert nur die Namen und Parameter einiger Methoden. Danach kann das Objekt bequem mit dem Schlüsselwort „implement“ verwendet werden. Die erforderlichen Schnittstellen werden integriert und anschließend der spezifische Ausführungscode hinzugefügt.
Beispiel 5: Schnittstelle
Schnittstelle anzeigbar {
Funktion display();
}
Schnittstelle zum Ausdrucken {
Funktion doprint();
}
Klasse foo implementiert displayable,printable {
Funktion display() {
// Code
} Funktion doprint() {
// Code
}
}
?>
Dies ist sehr hilfreich, um die Lesbarkeit und Popularität des Codes zu verbessern. Aus dem obigen Beispiel können wir ersehen, dass das Objekt foo zwei Schnittstellen enthält: displayable und printable. Zu diesem Zeitpunkt können wir klar erkennen, dass das Objekt foo eine Anzeige haben muss ()-Methode und einer print()-Methode verwenden, müssen Sie nur den Schnittstellenteil verstehen und können das Objekt problemlos bedienen, ohne sich darum kümmern zu müssen, wie das Objekt intern funktioniert.
Abstrakte Klassen
Abstrakte Klassen können nicht instanziiert werden.
Abstrakte Klassen ermöglichen wie andere Klassen die Definition von Variablen und Methoden.
Eine abstrakte Klasse kann auch eine abstrakte Methode definieren. Die Methode der abstrakten Klasse wird nicht ausgeführt, sie kann jedoch in ihrer abgeleiteten Klasse ausgeführt werden.
Beispiel 6: Abstrakte Klasse
abstrakte Klasse foo {
geschützt $x;
abstrakte Funktion display();
Funktion setX($x) {
$this->x = $x;
}
}
Klasse foo2 erweitert foo {
Funktion display() {
// Code
}
}
?>
__call
PHP5-Objekte verfügen über eine neue dedizierte Methode __call(), die zur Überwachung anderer Methoden in einem Objekt verwendet wird. Wenn Sie versuchen, eine Methode aufzurufen, die für das Objekt nicht vorhanden ist, wird die Methode __call automatisch aufgerufen.
Beispiel 7: __call
Klasse foo {
Funktion __call($name,$arguments) {
print("Hast du mich angerufen? Ich bin $name!");
}
} $x = new foo();
$x->doStuff();
$x->fancy_stuff();
?>
Mit dieser speziellen Methode können „Überladungs“-Aktionen implementiert werden, sodass Sie Ihre Parameter überprüfen und durch den Aufruf einer privaten Methode übergeben können.
Beispiel 8: Verwendung von __call zum Implementieren der Aktion „Überlastung“.
Klasse Magie {
Funktion __call($name,$arguments) {
if($name=='foo') {
if(is_int($arguments[0])) $this->foo_for_int($arguments[0]);
if(is_string($arguments[0])) $this->foo_for_string($arguments[0]);
}
} private Funktion foo_for_int($x) {
print("oh ein int!");
} private Funktion foo_for_string($x) {
print("Oh, ein String!");
}
} $x = new Magic();
$x->foo(3);
$x->foo("3");
?>
__set und __get
Dies ist eine großartige Methode. Die Methoden __set und __get können zum Erfassen von Variablen und Methoden verwendet werden, die in einem Objekt nicht vorhanden sind.
Beispiel 9: __set und __get
Klasse foo {
Funktion __set($name,$val) {
print("Hallo, Sie haben versucht, $val in $name einzufügen");
}
Funktion __get($name) {
print("Hey, du hast nach $name gefragt");
}
}
$x = new foo();
$x->bar = 3;
print($x->winky_winky);
?>
Typangabe
In PHP5 können Sie in der Methode eines Objekts angeben, dass sein Parameter eine Instanz eines anderen Objekts sein muss.
Beispiel 10: Typangabe
Klasse foo {
// Code ...
}
Klassenleiste {
öffentliche Funktion Process_a_foo(foo $foo) {
//Ein bisschen Code
}
}
$b = neuer Balken();
$f = new foo();
$b->process_a_foo($f);
?>
Wie man sieht, können wir den Namen eines Objekts explizit vor dem Parameter angeben, und PHP5 erkennt, dass es sich bei dem Parameter um eine Objektinstanz handelt.
Statische Mitglieder
Statische Mitglieder und statische Methoden werden in der Terminologie der objektorientierten Programmierung als „Objektmethoden (Klassenmethoden)“ und „Objektvariablen (Klassenvariablen)“ bezeichnet.
„Objektmethoden“ dürfen aufgerufen werden, bevor ein Objekt instanziiert wird. Ebenso können „Objektvariablen“ unabhängig gesteuert werden, bevor ein Objekt instanziiert wird (ohne die Methoden eines Objekts zu seiner Steuerung zu verwenden).
Beispiel 11: Objektmethoden und Objektvariablen
Klassenrechner {
static public $pi = 3.14151692;
statische öffentliche Funktion add($x,$y) {
return $x + $y;
}
}
$s = Rechner::$pi;
$result = Rechner::add(3,7);
print("$result");
?>
Ausnahmebehandlung
Die Ausnahmebehandlung gilt als ideale Methode zur Behandlung von Programmfehlern. Dieses Konzept ist in Java und C++ verfügbar. Wir freuen uns, dass diese Anwendung zu PHP5 hinzugefügt wurde. Sie können versuchen, Programmfehler mithilfe von „try“ und „catch“ zu kontrollieren.
Beispiel 12: Ausnahmebehandlung
Klasse foo {
Funktion dividieren($x,$y) {
if($y==0) throw new Exception("kann nicht durch Null dividieren");
return $x/$y;
}
}
$x = new foo();
versuchen {
$x->divide(3,0);
} Catch (Ausnahme $e) {
echo $e->getMessage();
Echo "n
N";
// Einige katastrophale Maßnahmen hier
}
?>
Im obigen Beispiel haben wir „try“ verwendet, um die Anweisung in geschweiften Klammern auszuführen. Wenn ein Fehler auftritt, übergibt der Code den Fehler zur Verarbeitung in der „catch“-Klausel Durch die Behandlung von Fehlern an einem Objekt kann die Codestruktur klarer aussehen, da wir jetzt alle Fehlerinformationen zur Behandlung an ein Objekt übergeben können.
Benutzerdefinierte Fehlerbehandlung
Mit benutzerdefiniertem Fehlerbehandlungscode können Sie Unfälle in Ihrem Programm einfach kontrollieren. Sie müssen lediglich Ihre eigene Fehlerkontrollklasse von der Ausnahmeklasse ableiten. In Ihrer eigenen Fehlerkontrollklasse benötigen Sie einen Konstruktor und eine getMessage-Methode.
Beispiel 13: Benutzerdefinierte Fehlerbehandlung
Klasse WeirdProblem erweitert Ausnahme {
private $data;
Funktion WeirdProblem($data) {
parent::Exception();
$this->data = $data;
}
Funktion getMessage() {
return $this->data . „hat eine seltsame Ausnahme verursacht!“;
}
}
?>
Jetzt können wir „throw new WeirdProblem($foo)“ verwenden, um einen Fehlerhandler auszulösen. Wenn der Fehler im „try“-Codeblock auftritt, übergibt PHP5 den Fehler automatisch an den „catch“-Teil zur Verarbeitung.
Namespaces
Namespaces sind nützlich für die Gruppierung von Klassen oder Funktionen. Es kann einige verwandte Klassen oder Funktionen gruppieren, um sie später einfacher aufrufen zu können.
Beispiel 14: Namensraum
Namespace Math {
Klasse Komplex {
//...Code...
Funktion __construct() {
print("hey");
}
}
} $m = new Math::Complex();
?>
Achten Sie auf die Umstände, unter denen Sie Namespaces verwenden müssen. In praktischen Anwendungen müssen Sie möglicherweise zwei oder mehr Objekte mit demselben Namen deklarieren, um unterschiedliche Aufgaben auszuführen. Anschließend können Sie sie in unterschiedliche Namespaces einfügen das gleiche).