| |
| * Link führt ins Internet |
|
| |
Vertiefung der OOP-Techniken
|
|
In diesem Abschnitt wollen, wir Ihre Kenntnisse mit Hilfe der Grafikbibliothek GD vertiefen, so dass Sie ohne weiteres mit der Entwicklung eigener OO-basierten Projekten beginnen können.
| Hinweis: Sie erfahren mehr zur GD-Bibliothek weiter unten, im Abschnitt Dynamische Grafiken mit der GD-Bibliothek. |
Klassen und Objekte
Im folgenden Beispiel wird als erstes eine Klasse welt definiert. Diese Klasse wurde als Basisklasse für die Anzeige von einfachen grafischen Objekten im Browser erzeugt.
Die Klasse setzt sich aus den benötigten Klassenvariablen und dem Konstruktor zusammen.
. $bild ist der Verweis auf das zu erzeugende Bild, welche die virtuelle Welt darstellt.
. $posx und $posy sind Variablen mit denen auf eine beliebige Koordinate x/y auf der welt verwiesen werden kann.
. $schwarz, $rot und $blau sind Variablen die zur Festlegung der jeweiligen Farbwerte dienen.
Der Konstruktor welt(), der denselben Namen trägt wie die Klasse, wird dazu verwendet, die Initialisierungen vorzunehmen.
Die Klassenvariablen für die jeweiligen Farbwerte werden mit Hilfe der GD-Funktion imageColorAllocate() festgelegt.
Header ("Content-type: image/gif");
class welt {
var $bild;
var $posx=0;
var $posy=0;
var $schwarz;
var $rot;
var $blau;
function welt($img) {
$this->bild = $img;
$this->schwarz = imageColorAllocate($this->bild, 0,0,0);
$this->weiss = imageColorAllocate($this->bild, 255, 255, 255);
$this->rot = imageColorAllocate($this->bild, 255, 0, 0);
$this->blau = imageColorAllocate($this->bild, 200, 200, 255);
imagefill($this->bild, 10,10,$this->blau);
}
}
|
Anschliessend wird die Objektinstanz erzeugt, wie Sie bereits wissen ist hierfür das Schlüsselwort new notwendig. Im Beispiel wird die Instanz den Namen $meineWelt erhalten, welche von der Klasse welt abgeleitet wird.
$einbild = imagecreate(300, 300);
$meineWelt = new welt ($einbild);
|
Die GD-Funktion imagecreate() sorgt dafür, dass Ihnen ein Grundgerüst für Ihr Bild zur Verfügung steht.
Um das neue Objekt anzeigen zu können, muss nun noch die GD-Funktion imagejpeg() mit dem Verweis auf das erzeugte Bild als Parameter aufgerufen werden. Anschliessend sollten Sie noch das Bild, mit Hilfe der GD-Funktion imagedestroy(), aus dem Speicher entfernen.
imagejpeg($einbild);
imagedestroy($einbild);
|
| Hinweis: Die GD-Funktionen haben mit dem eigentlich Thema nichts zu tun. Sie dienen lediglich der Visualisierung. |
Sicher werden nun einige von Ihnen denken, dass hätten wir auch einfacher haben können. Natürlich, aber wir haben schliesslich noch mehr mit der Klasse vor. Nun wird es interessant, wie sieht es mit der Vererbung aus, lässt sich diese auch auf unsere Klasse welt anwenden.
Vererbung
Die Welt soll um einen virtuellen Kontinent erweitert werden, symbolisch durch ein Rechteck symbolisiert. Hierzu wird eine neue Klasse mit dem Namen kontinent definiert. An diese neue Klasse sollen sämtliche Eigenschaften der schon bestehenden Klasse welt vererbt werden.
class kontinent extends welt{
function flaeche() {
imagefilledrectangle($this->bild, $this->posx, $this->posy, $this->posx+200, $this->posy+200, $this->rot);
}
function erzeuge($newx,$newy) {
$this->posx=$newx;
$this->posy=$newy;
$this->flaeche();
}
}
|
Um ein Objekt der Klasse zu erzeugen muss lediglich folgende Codezeile angepasst werden:
$meineWelt = new kontinent($einbild);
|
Anschliessend muss die Methode erzeuge() des Objekts $meineWelt aufgerufen werden.
$meineWelt->erzeuge(50,50);
|
| Hinweis: Wenn Sie den Code der neuen Klasse kontinent aufmerksam betrachten, wird Ihnen auffallen, dass dieser keinen Konstruktor enthält. Dies ist auch nicht erforderlich, da in abgeleiteten Klassen die Konstruktoren der Elternklasse aufgerufen werden, falls die abgeleiteten Klassen selbst keine Konstruktoren besitzen. Dieses Feature steht seit PHP 4 zur Verfügung. |
Überschreiben von Methoden
Nun da wir auch noch über einen Kontinent auf unserer virtuelle Welt verfügen, sollten wir hier und dort noch einige Lebewesen platzieren. Wir greifen auch in diesem Fall wieder auf die Vererbung zurück und definieren eine Klasse lebewesen und vererben dieser sämtliche Eigenschaften und Methoden der Klasse kontinent.
Die Klasse lebewesen soll eine zusätzliche Methode enthalten, die anhand eines ausgefüllten Kreises ein Lebewesen darstellt. An diesem Punkt stossen wir auf ein weiteres zentrales Konzept der objektorientierten Programmierung, das Überschreiben von Methoden.
Da wir mit der Methode erzeugen() bereits eine Methode zur Positionierung grafischer Objekte zur Verfügung haben, benötigen wir nur noch eine neue Methode flaeche(), die anstelle eines Rechtecks einen ausgefüllten Kreis erzeugt.
In der OOP-Terminologie nennt man den Vorgang, wenn eine in einer Elternklasse vorhandene Methode in einer Kindklasse neu definiert wird, eine Methode überschreiben, und genau das ist hier erforderlich. Die neue Methode flaeche() ist mit Hilfe der GD-Funktionen imagearc() und imagefilltoborder() schnell umgesetzt.
class lebewesen extends kontinent {
function flaeche() {
imagearc($this->bild, $this->posx, $this->posy, 50, 50, 0, 360, $this->schwarz);
imagefilltoborder($this->bild, $this->posx, $this->posy, $this->schwarz, $this->schwarz);
}
}
|
Wenn wir von der neuen Klasse lebewesen in der nun schon gewohnten Weise Instanzen, z.B. $lebewesen1 ableiten, sollte der Aufruf der Methode erzeugen() dieser Klasse, die lebewesen von kontinent geerbt hat, dazu führen, dass erzeugen() die in lebewesen überschriebene Methode flaeche() aufruft, die anstelle von Rechtecken Kreise darstellt.
$lebewesen1 = new lebewesen($einbild);
$lebewesen1->erzeuge(100,100);
$lebewesen2 = new lebewesen($einbild);
$lebewesen2->erzeuge(200,200);
|
Beispiel - vollständig
<?
Header ("Content-type: image/jpeg");
class welt {
var $bild;
var $posx=0;
var $posy=0;
var $schwarz;
var $rot;
var $blau;
function welt($img) {
$this->bild = $img;
$this->schwarz = imageColorAllocate($this->bild, 0,0,0);
$this->weiss = imageColorAllocate($this->bild, 255, 255, 255);
$this->rot = imageColorAllocate($this->bild, 255, 0, 0);
$this->blau = imageColorAllocate($this->bild, 200, 200, 255);
imagefill($this->bild, 10,10,$this->blau);
}
}
class kontinent extends welt{
function flaeche() {
imagefilledrectangle($this->bild, $this->posx, $this->posy, $this->posx+200, $this->posy+200, $this->rot);
}
function erzeuge($newx,$newy) {
$this->posx=$newx;
$this->posy=$newy;
$this->flaeche();
}
}
class lebewesen extends kontinent {
function flaeche() {
imagearc($this->bild, $this->posx, $this->posy, 50, 50, 0, 360, $this->schwarz);
imagefilltoborder($this->bild, $this->posx, $this->posy, $this->schwarz, $this->schwarz);
}
}
$einbild = imageCreate(300, 300);
$meineWelt = new kontinent($einbild);
$meineWelt->erzeuge(50,50);
$lebewesen1 = new lebewesen($einbild);
$lebewesen1->erzeuge(100,100);
$lebewesen2 = new lebewesen($einbild);
$lebewesen2->erzeuge(200,200);
imagejpeg($einbild);
imagedestroy($einbild);
?>
|
Die anhand dieses Beispiels aufgezeigten OOP-Prinzipien sollten Sie sich gut einprägen, da diese Ihnen bei umfangreichen Projekten eine menge Arbeit ersparen können und Ihr Code wesentlich flexibler für Erweiterungen und Anpassungen wird.
|
|
|
|
|
|
|
SELFPHP
SELFPHP - Damir Enseleit, info@selfphp.de, Impressum, Kontakt