[An die Profis hier: Sollte ich etwas wichtiges vergessen haben, etwas für Anfänger unschlüssig Erklärt haben oder ich etwas rauslassen sollte, sagts mir :)]
[Du benötigst dafür mindestens PHP 5, da die objektorientierte Programmierung in PHP 4 stark hiervon abweicht und damals noch nicht alle Möglichkeiten hatte.]
Hallo,
ich möchte euch heute in diesem Tutorial erklären, was es mit objektorientierter Programmierung in PHP aufsich hat.
Objektorientierte Programmierung eignet sich gut um Teile eines Scripts in weiteren Scripten weiterverwenden zu können.
In diesem Tutorial werd ich mit euch die Klasse Pflanze entwerfen.
Zuerst einmal die Frage, was sind Objekte und Klassen.
Eine Pflanze ist ein in dem Fall ein Objekt. Ein Objekt wäre auch ein Grashalm,
eine Blume oder derartiges. Eine Klasse ist eine Vorlage für ein Objekt.
Wenn man ein Objekt aus einer Klasse erstellt nennt man dies auch Instanz.
Wenn wir jetzt einen Rasen haben besteht dieser aus vielen Grashalmen.
Jeder Grashalm ist eine Instanz der Klasse Grashalm.
Eine Klasse besteht aus Methoden und Eigenschaften.
Fangen wir nun an eine Klasse für Pflanzen zu erstellen.
Die Klasse Pflanze soll eine Eigenschaft besitzen, in der steht welche Farbe sie haben soll.
Auf diese Eigenschaft soll auch von aussen zugegriffen werden können.
<?php class Pflanze { public $color = 'green'; }?>Jetzt erstellen wir ein Objekt dieser Pflanze. Dieser weisen wir die Farbe gelb zu, weil sie verwelkt ist.
Zuletzt geben wir die Farbe der Pflanze aus.
<?php $pflanze = new Pflanze(); $pflanze->color = 'yellow'; echo $pflanze->color;?>Jetzt wär es praktisch, wenn man der Pflanze schon beim Erstellen eine Farbe übergeben könnte.
Das lösen wir, indem wir eine Methode namens __construct() definieren. Diese wird aufgerufen,
wenn man eine neue Instanz des Objekts erstellt.
<?php class Pflanze { public $color = 'green'; public function __construct ($color) { $this->color = $color; } }?>Eine Pflanze erstellt man dann so:
<?php $pflanze = new Pflanze('yellow'); echo $pflanze->color;?>An diesem Beispiel erkennt man schon 2 neue Dinge.
Erstens kann man die Sichtbarkeit der Funktionen auch bestimmen. In diesem Fall public, damit auf sie
auch von aussen zugegriffen werden kann. Neben public gibt es noch private und protected.
Private Variablen könenn nur von der Klasse selbst benutzt werden. Was protected gesetzte Variablen machen,
wird später im Tutorial erklärt.
Zweitens die Variable $this. Mit $this kann man innerhalb der Klasse auf die eigenen Methoden und Eigenschaften
zugreifen.
Der Pflanze fügen wir jetzt noch die Funktion wachsen($größe) hinzu. Damit wächst die Pflanze um die angegebene
Größe. Um auch private zu testen setzen wir die Variable in der die Größe gespeichert wird private. Übersetzt ins Englische wär das dann
die Eigenschaft $size mit der Methode grow ($size). Das ganze sieht dann so aus:
<?php class Pflanze { public $color = 'green'; private $size = 10; public function __construct ($color) { $this->color = $color; } public function grow ($size) { $this->size += $size; } }?>Das sieht doch schon ganz gut aus.
Mit $pflanze->grow(5); kann man sie 5cm wachsen lassen.
Jetzt möchten wir noch eine Klasse Blume erstellen. Die Blume hat eine Blüte, die eine eigene Farbe hat und
eine Funktion zum öffnen und eine zum schließen der Blume. (Ob Blumen biologisch betrachtet ihre Blüte
öffnen und schließen können sei jetzt mal dahin gestellt.)
Allerdings ist eine Blume auch eine Pflanze. Deshalb benötigt sie auch die Funktion grow und die Farbe.
Damit wir nicht alles nocheinmal machen müssen, können wir die Klasse Blume von der Klasse Pflanze ableiten.
Dadurch erhält sie alle Methoden und Eigenschaften der Klasse Pflanze.
Die Klasse Pflanze nennt man dann Elternklasse und die Klasse Blume Kindklasse.
Jetzt erstmal der Code, dann die Erklärung.
<?php class Blume extends Pflanze { public $color2 = 'yellow'; private $opended = false; public function open () { $this->opened = true; } public function close () { $this->opened = false; } }?>Jetzt möchten wir, dass die Blüte mit der Blume wächst.
Die Eigenschaft $size ist allerdings private, dass heisst nur die Klasse selbst kann darauf zugreifen.
Damit auch die Kindklasse darauf zugreiffen kann müssen wir sie protected setzen.
Auf als protected gesetzte Variablen können nur die eigene Klasse und die Kindklassen zugreifen.
Damit die Blüte mitwachsen kann, müssen wir die Funktion grow überschreiben sowie eine neue
Eigenschaft $size2 hinzufügen, in der die Größe der Blüte gespeichert wird.
Das ganze sieht so aus:
<?php class Pflanze { public $color = 'green'; protected $size = 10; public function __construct ($color) { $this->color = $color; } public function grow ($size) { $this->size += $size; } } class Blume extends Pflanze { public $color2 = 'yellow'; private $opended = false; private $size2 = 5; public function open () { $this->opened = true; } public function close () { $this->opened = false; } public function grow ($size) { $this->size += $size; $this->size2 += ($size / 2) } }?>Die Funktion grow könnte man auch so schreiben:
<?php
public function grow ($size) {
parent::grow($size);
$this->size2 += ($size / 2)
}
?>Damit führt man die grow-Methode der Elternklasse mit aus.
Weiteres zu parent und :: vielleicht in einem weiterem Teil dieses Tutorials.
Desweiteren sind auch Klassen möglich, von denen man keine Instanz erstellen muss, um sie zu nutzen.
Aber das bei Interesse alles in einem weiterem Tutorial.
Zum Schluss noch etwas zur Ordnung:
Klassen speichert man für gewöhnlich alle in einzelnen Dateien. Die benennt man in der Form
Klassenname.class.php. Die Klassen müssen dann im Script nurnoch mit include() oder require()
bzw. include_once() oder require_once() eingebunden werden.
Hier ein paar Aufgaben, die ihr zum Üben benutzen könnt. Die Lösungen könnt ihr an mich schicken und
ich werde sie bewerten und bei Problemen helfen.
- Erweiter die Klasse Pflanze und die Klasse Blume um die Funktionen, mit der man die Größe der Pflanze und der Blüte herrausbekommt.
- Änder die __construct-Methode so ab, dass man bei der Blume die Blütenfarbe mit bestimmen kann.
