[messagebox=error]
Dieses Tutorial eigenet sich nicht für Anfänger. Bitte zuerst die Tutorialreihe von Ben Escobar durcharbeiten.
[/messagebox]

Hallo,

in dieser Tutorialreihe möchte ich euch zeigen wie man mittels PHP5 objektorientiert programmiert.

Inhalt

1. Was ist objektorientierte Programmierung?
2. Klassen, Objekte und Methoden
3. Paamayim Nekudotayim
4. Zeiger
5. Magische Methoden
6. Polymorphie
7. Sichtbarkeit
   

Unter objektorientierter Programmierung versteht man das Programmieren anhand von Objekten. Ok. Das haben sich einige bestimmt schon gedacht. Aber was heißt das nun?
Im Prinzip ist es ganz einfach.

Sehen wir uns ersteinmal die imperative Programmierung an:


Hierbei wird das Skript stur von oben bis unten abgearbeitet und erzeugt folgende Ausgabe:

1
2
3
10
5
6
7
8
9
10

Bei der Technik der objektorientierten Programmierung gibt es einen großen Punkt: Datenkapselung. Unter diesem Begriff versteht man das Verbergen von Informationen vor den Außenstehenden. So fasst man Funktionen die zur selben Funktionsgruppe gehören in Klassen zusammen. Um diese Funktionen dann zu benutzen muss man ein Objekt der Klasse erzeugen. Daher kommt auch der Name der Programmierart. Man orientiert sich an Objekten.

Von allen Programmierarten ist die objektorientierte der Realität am nächsten.
Nehmen wir mal an das wir mit dem Auto fahren wollen. Bevor wir dies können,müssen wir uns ein Auto besorgen (kaufen). Wegen der Einfachheit erzeugen wir es uns einfach. Dies wäre dann unsere Objekt. Unser Objekt bekommt verschiedene Eigenschaften wie die Farbe, die Höchstgeschwindigkeit, die Anzahl der Sitzplätze und die Höchstgeschwindigkeit. Dies nennt man Attribute. Dann gibt es noch Fähigkeiten unseres Objektes. Dies sind die Methoden. Zu den Methoden (Fähigkeiten) zählt alles das was unserem Objekt eine Funktion gibt. Bei unserem Beispiel ist die einfachste Fähigkeit das Fahren.
Wie müssen uns also erst ein Objekt erzeugen, dann die nötigen Attribute setzen und zum Schluss können wir dann die Methoden nutzen.

So. Nun widmen wir uns den genannten drei Begriffen.

Was ist eine Klasse?
Wie erzeugt man Objekte?
Wie benutzt man Methoden?

Ersteinmal schauen wir uns den Begriff "Klasse" an. Wie bereits erwähnt ist eine Klasse eine Ansammlung von Funktionen welche alle logisch zusammengehören. Wenn wir bei unserem Beispiel bleiben, heißt unsere Klasse "Auto". Klassen werdem mit dem Schlüsselwort definiert. Darauf folgt der Klassenname. Der Klassenkörper wird wie bei Funktionen mit Hilfe von einer geschweiften Klammer geöffnet bzw. wieder geschlossen. Dies sieht dann so aus:Um die Klasse nun nutzen zu können, müssen wir erst ein Objekt der Klasse erzeugen. Dies funktioniert mit dem Schlüsselwort gefolgt von dem Klassennamen und einer runden Klammer welche direkt wieder geschlossen wird:
Nur was kann unser Objekt jetzt? Die Antwort: nichts. Ersteinmal müssen wir der Klasse und damit dem Objekt eine Funktion geben. Im gleichen Arbeitsschritt können wir ihr auch ein paar Attribute also Eigenschaften einprogrammieren. Dies sieht dann so aus:

Das "public" ignorieren wir an dieser Stelle ersteinmal. Es soll uns genügen das es da ist. Ansonsten werden die Attrute genauso wie normale Variablen und die Methoden wie Funktionen definiert.
Wie benutzen wir das nun? Nehmen wir mal an wir haben ein blaues Auto, mit 5 Sitzen und einer Höchstgeschwindigkeit von 180 Kilometern pro Stunde. Um auf die Attribute bzw Methoden unserer Klasse zuzugreifen benutzen wir eine Pfeilnotation. Diese sieht folgendermaßen aus: Zuerst kommt der Name unseres Objektes, dann kommt der Pfeil -> und zum Schluss dann der Name unsereres Attributes bzw. Methode. Hier ist zu beachten das man bei den Attributen das Dollarzeichen weglässt und bei Methode die gewohnten runden Klammern schreibt. Unser Programm sieht dann also so aus:
Nun zur Erkärung:
In Zeile 1 instanziieren wir unser Objekt der Klasse Auto.
In Zeile 2 - 5 weisen wir unseren Attributen die entsprechenden Werte zu.
Zum Schlusss rufen wir in Zeile 6 die Methode fahren() auf. Diese Methode gibt dann den Text "Unser Auto fährt" aus.

Hat der zu viel Weihnachten gefeiert?

Nein, habe ich nicht. Denn das Wort "Paamayim Nekudotayim" bezeichnet in der Programmiersprache PHP den Doppel-Doppelpunkt (::).

Er wird bei dem Zugriff auf statische Elemente verwendet. Bloß was sind statische Elemente. Hier zitiere ich einfach mal das PHP-Handbuch:

Handbuch PHP schrieb:

Klassenmember oder -methoden als statisch zu deklarieren macht diese zugänglich, ohne dass man die Klasse instantiieren muss. Auf ein als statisch deklariertes Member kann nicht mit einem instantiierten Klassenobjekt zugegriffen werden (obgleich eine statische Methode dies kann).

Wer hat das nun verstanden? Da ich jetzt einfach mal davon ausgehe das dies die Minderheit ist, erkläre ich es nun. Bisher hatten wir eine Klasse Auto mit der Eigenschaft farbe (unter anderem). Nun mussten wir bevor wir auf die Eigenschaft zugreifen konnten (sie entweder mit Werten füllen oder aber ihren Inhalt abrufen) die Klasse instaziieren (ein Objekt erzeugen).
Dies sah so aus:Wenn wir jetzt wissen wollen wie viele Autos bisher erzeugt wurden, können wir das nur über eine Art machen welche wir aber über verschiedene Arten implementieren können. Die einzigste Möglichkeit dieses Problem zu lösen liegt darin einen Zähler zu erstellen der nach jedem instanziieren der Klasse Auto um eins hochgezählt wird. Der Bequemlichkeit halber wollen wir diese als weitere Eigenschaft der Klasse definieren. Wir lösen es also so:
Wenn wir unsere beiden Objekte welche in $meinAuto und $meinAuto2 gepseichert sind mittels der Funktion print_r() ausgeben lassen, stellen wir fest das die Variable $verkauft in beiden Fällen den Wert "1" beinhaltet. Aber das ist ja nicht so ganz was wir wollen. Das liegt daran das $verkauft eine Objektvariable ist. Wir benötigen also eine Variable die global für alle von dieser Klasse erzeugten Objekte gilt. Dies nennt man eine Klassenvariable. Solche Klassenvariablen deklariert man mit dem Schlüsselwort Unsere Klasse sieht also wie folgt aus:Nun, wie greifen wir auf diese Variable zu? Ganz einfach. Mit dem Doppel-Doppelpunkt. Dazu muss man auch den Namen der Klasse wissen. Wir erzeugen uns also zwei Objekte der Klasse Auto und inkrementieren nach jedem Instanziieren der Klasse den Wert der Klassenvariablen:Man beachte das Dollarzeichem hinter dem Doppel-Doppelpunkt. Geben wir am Schluss den Inhalt der Variablen aus, sehen wir das diese den Wert "2" hat. Um zu kontrollieren ob diese Eigenschaft wirklich für alle von der Klasse Auto erzeugten Objekte gültig ist, müssen wir nur die Variable innerhalb des Objektes ausgeben. Dafür können wir eine neue Methode schreiben die dies erledigt.Um innerhalb der Klasse auf die statische Eigenschaft zuzugreifen, gibt es noch einen bestimmten Zeiger. Im Augenblick soll uns aber der Objektzeiger ($meinAuto) und der Klassenzeiger (Auto) reichen.

Nun werde ich erklären was Zeiger sind und wofür diese gut sind.

Bisher lernten wir zwei Zeigerarten kennen. Den Objektzeiger und den Klassenzeiger. Der Objektzeiger ist das von uns erzeugte Objekt. Also $meinAuto bzw. $meinAuto2. Unser Klassenzeiger war bisher immer der Klassenname Auto (Wir erinnern uns auf das Zugreifen auf das statische Element $verkauft). An dieser stelle möchte ich euch noch zwei weitere Zeiger mitgeben. Einmal wäre dies $this und einmal self. Beide dieser Zeiger werden innerhalb von Klassen verwendet um auf ein Element selbiger zuzugreifen.
Der Zeiger $this ist dabei nur bei instanziierten Klassen verwendbar. Dies verrät schon das man damit Zugriff auf nicht-statische Elemente bekommt. Nun werden sich die pfiffigen unter euch schon den Rest denken. Mit self bekommt man Zugriff auf statische Elemente. Im Bezug auf unser Beispiel sieht dies so aus:Beim Aufruf der Methode fahren() wird uns nun mitgeteilt wie schnell das Auto maximal fahren kann.

Was versteht man unter magischen Methoden, was bewirken diese, wofür braucht man sie? Diese Fragen werde ich hier klären. Allerdings werde ich nicht auf alle magischen Methoden eingehen da manche meines Erachtens nach unnötig sind.

Ein wenig Theorie vorab: Allen magischen Methoden sind zwei Sachen gemeinsam.

1. Ihre Deklarierung beginnt immer mit zwei aufeinander folgenden Unterstrichen (__)
2. Sie sollen nicht manuell aufgerufen werden sondern automatisch. Dabei werden diese nicht immer ausgeführt sondern erst dann wenn es innerhalb des Systems von Nöten ist.

Hier mal eine Liste aller Methoden die ich hier behandeln werde:

1. __construct()
2. __destruct()
3. __autoload()
4. __toString()
5. __get()
6. __set()

[anchor=construct][/anchor]
__construct()

Die meiner Meinung nach wichtigste Methode ist Der Konstruktor Wenn diese Methode implementiert wurde, wird sie automatisch beim Instanziieren der zugehöhrigen Klasse aufgerufen. Sollte der Konstruktor Parameter erwartet, werden diese bei der Instanziierung innerhalb der runden Klammern übergeben. Damit wird es möglich bestimmte Methoden der Klasse automatisiert bei der Instanziierung aufzurufen oder einzelne Attribute vorzubelegen. Bezogen auf unsere Klasse Auto sähe das so aus:

[anchor=construct][/anchor]
__destruct()

Der Destruktor ist das genaue Gegenteil den Konstruktors. Entsprechend wird er implementiert:Allerdings akzeptiert der Destruktor keinerlei Parameter. Diese magische Methode wird automatisch bei der Zerstörung aller Referenzen auf ein Objekt aufgerufen. Bei unserem Beispiel sieht das Ganze so aus:Hier wird zum Schluss, wenn die Seite vollständig geladen ist, der Text "Zerstöre Objekt" ausgegeben. Diese Methode ist hauptsächlich aus Performancegründen wichtig da es damit möglich wird alle verwendetetn Variablen zu löschen.
[anchor=autoload][/anchor]
__autoload()

Um diese Funktion zu Verstehen muss man ein wenig drumherum reden. Viele Entwickler (mich eingeschlossen) programmieren für jede Klasse eine eigene Datei. Dies bewahrt die Übersicht und hilft bei der Fehlersuche. Folge dessen ist allerdings eine lange Liste von includes. Dies rührt daher das eine Klasse vor ihrer Verwendung verfügbar sein muss. Dies lässt sich mit der Funktion __autoload() umgehen. Die Methode benötigt genau einen Parameter. Und zwar den Namen der zu ladenden Klasse:Auf unser Beispiel bezogen sieht das Ganze so aus: Wir lagern unsere Klasse in die Datei Auto.class.php aus:Entsprechend unsere index.php:[messagebox=error]Beachte bitte das diese Funktion durch spl_autoload_register() ersetzt wurde und vermutlich bald als veraltet gekennzeichnet wird.[/messagebox]
[anchor=tostring][/anchor]
__toString()

Diese Methode gehört zu den einfachsten ihrer Art. Sie wird automatisch aufgerufen wenn das Objekt der Klasse in eine Zeichenkette konvertiert wird. In unserem Beispiel soll dabei einfach der gleiche Text wie bei der Methode fahren() ausgegeben werden. Unsere Klasse Auto.class.php:Und unsere index.php:
[anchor=get][/anchor]
__get()

Die magische Methode __get() wird immer dann aufgerufen wenn versucht wird auf eine nicht existente Eigenschaft zuzugreifen. Dies ist nützlich wenn man bspw. alle Attribute in einem Array speichern möchte ohne diese über das Array abzurufen:
[anchor=set][/anchor]
__set()

[messagebox=error]Mit dieser Methode wird häufig ein Workaround für fehlerhaften Code geschaffen. Ich persönlich rate von der Verwendung dieser Methode ab. Sollte es nícht zu verhindern sein, setzt diese Funktion bitte gewissenhaft ein.[/messagebox]Deswegen werde ich an dieser Stelle auch kein Beispiel dafür posten sondern lediglich auf die Funktion hinweisen. Diese Methode wird immer dann aufgerufen wenn versucht wird eine nicht existente Eigenschaft zu setzen.
[messagebox=info]Als kleine Anmerkung sei gesagt das obwohl alle Methoden mit zwei führenden Unterstrichen als magische Methoden eingestuft werden folgende Methoden nicht zu den magischen Methoden sondern zu den Interceptormethoden gehören:

1. __autoload()
2. __call()
3. __callStatic()
4. __get()
5. __set()

[/messagebox]

Das Wort Polymorphie kommt aus dem griechischen und bedeutet Vielseitigkeit. Dies meint das ein Bezeichner der abhängig seines Verwendungszwecks eine andere Bedeutung hat. Solche Bezeichner gibt es z.B. auch in der deutschen Sprache.
Dafür für ich als Beispiel das Wort Leiter
Da fallen mir jetzt drei verschiedene Bedeutungen ein:

1. Leiter (=treppenähnliche Aufstiegshilfe)
2. Leiter (=Chef eines Institutes)
3. Leiter (=physikalischer Träger, z.B. für Strom)

Was bedeutet das nun für uns? Wir können diese Fähigkeit benutzen um eine fertige Klasse oder eine Methode zu erweitern ohne ihren Quellcode zu kennen. Dies geschieht mittels Vererbung. Wie lässt sich diese Vererbung vorstellen? - Ganz einfach:
Vererbung in der Programmierung verhält sich wie bei Lebewesen. Man hat eine Basisklasse. Erbt nun eine andere Klasse von dieser, übernimmt sie automatisch (so fern nicht anders angegeben) alle Methoden und Attribute der Basisklasse. Welche Elemente vererbt werden dürfen, legt man über die Sichtbarkeit fest. Hierzu aber später mehr.

Auf unser Beispiel bezogen, können wir uns eine Basisklasse Kraftwagen erzeugen und von ihr dann die beiden Klassen PKW und LKW erben lassen. Die Vererbung führt man mit Hilfe des Schlüsselwortes extends aus. Hier mal unsere neue Klassenstruktur:Nun haben wir uns also zwei Objekte erzeugt. Eines von der Klasse LKW und eines von der Klasse PKW. da beide Klassen von der Basisklasse Kraftwagen erben und ansonsten keine eigenen Attribute oder Methoden enthalten, sind beide Klassen identisch (aber dennoch verschieden!). Wenn wir nun davon ausgehen das LKWs auschließlich von Firmen gehalten werden und PKS dagegen von Privatpersonen, lässt sich folgendes realisieren: Sollten wir jetzt aber versuchen auf das Attribut firma der Klasse PKW zugreifen, erhalten wir einen Fatal Error da das Attrbut nicht existiert.

Ein wichtiger Teil der Polymorphie ist das Methodenüberschreiben. Im Gegensatz zu anderen Programmiersprachen geht dies in PHP ganz einfach. wir deklarieren die zu überschreibende "Basisklassenmethode" in der Kindklasse einfach neu. Soll eine Methode stattdessen erweitert werden, müssen wir uns zu erst einen neuen Zeiger angucken.
Neben den in Teil 4 genannten Zeigern existiert noch ein weiterer, welcher immer auf die (direkte) Basisklasse zeigt. Dieser Zeiger nennt sich parent. Dieser Zeiger wird nach folgendem Muster verwendet:Wenn wir uns jetzt die Unterschiede zwischen einem LKW und einem PKW anschauen, fällt uns auf das ein LKW in der Regel eine Ladefläche hat und ein PKW nicht. Jetzt haben wir mehrere Möglichkeiten um dies einzubringen:

1. Wir erstellen in der Klasse LKW ein neues Attribut auf welches wir direkt zugreifen
2. Wir erstellen in der Klasse LKW ein neues Attribut und eine neue Methode über die wir auf das Attribut zugreifen
3. Wir erstellen in der Klasse LKW ein neues Attribut und erweitern den Konstruktor dahingehend dass das neue Attribut bei der Instanziierung gesetzt wird.

Wir entscheiden und hier für Möglichkeit drei:Wie man sieht, habe ich in der Klasse LKW einen neuen Konstruktor angelegt der die gleichen Parameter enthält wie der Konstruktor der Basisklasse. Zusätzlich haben wir hier einen weiteren Parameter der für die Ladefläche zuständig ist. Der "neue" Konstruktor setzt nun das Attribut ladeflache auf den Value der Parameters ladeflaeche und ruft danach dem Konstruktor der Basisklasse mit den nötigen Parametern.

Die Sache mit der Sichtbarkeit.

Prinzipiell ist dieser Part schnell erklärt. Leider geht dies mit Autos nicht besonders gut (wenn jemand weiß wie, kann er mir das gerne melden und wenn es mir gefällt ändere ich es und setze denjenigen als Urheber darunter).

Die Sichtbarkeiten legen fest von wo aus man auf die Attribute und Methoden einer Klasse zugreifen darf.
An Sichtbarkeitsstufen gibt es drei Stück:

1. public
2. protected
3. private

Der schlaue Leser wird wissen dass ich die drei Sichtbarkeiten aus einem guten Grund in der Reihenfolge schrieb. Das sind die drei Stufen mit denen man den Zugriff festlegen kann. Dabei ist public die freigiebigste und private die geschlossenste Stufe.

Übernehmenen wir nun zuerst die Klassen aus dem vorherigen Post und verändern sie so wie sie in der Praxis angewendet werden:


Ich erkläre kurz wie die Sichtbarkeiten arbeiten:

1. public: Jedes Attribut und jede Methode die mit dieser Sichtbarkeit deklariert wurde, ist außerhalb der Klasse oder des Objektes aufrufbar.
   
2. protected: Auf diese Attribute und Methoden kann nur innerhalb der Klassen und Objekte in denen die Definierung stattgefunden hat zugegriffen werden. Zusätzlich ist es den Erben der Klasse gestattet darauf zuzugreifen.
   
3. private: Diese Attribute und Methoden sind nur innerhalb der Klasse und des Objektes erreichbar. Ein Zugriff von außerhalb ist nicht gestattet/möglich!