() translation by (you can also view the original English article)
PHP ist so viel mehr als eine Skriptsprache. Es ist eine vollwertige Sprache, die sehr komplexe Anwendungen erstellen kann. Indem Sie die volle Leistung der objektorientierten Programmierung nutzen, können Sie den Zeitaufwand für das Codieren reduzieren und damit bessere Websites erstellen. Dieses Tutorial zeigt Ihnen, wie.
Was ist OOP?
OOP steht für Object Oriented Programming. OOP ist ein Programmierparadigma, bei dem Sie "Objekte" erstellen, mit denen Sie arbeiten können. Diese Objekte können dann auf Ihre spezifischen Anforderungen zugeschnitten werden, um verschiedene Arten von Anwendungen unter Beibehaltung derselben Codebasis zu bedienen. Sehr nützlich.
Was ist ein Objekt?
Ein Objekt ist einfach eine Kopie oder Instanz einer "Klasse". Eine Klasse kann als "Black Box" definiert werden, von der aus wir unsere Objekte erstellen und auf ihre Attribute (Variablen) und Methoden (Funktionen) zugreifen. Die gebräuchlichste Analogie bei der Erklärung von Klassen und OOP ist, wie Sie ein Auto fahren: Grundsätzlich haben Sie 2 oder 3 Pedale, einen Schalthebel und ein Lenkrad. Sie müssen (und wollen höchstwahrscheinlich nicht) wissen, wie das Auto funktioniert, wenn Sie in die Pedale treten. Sie möchten nur, dass Ihr Auto links und rechts hin und her fährt. Und genau das ist OOP. Sie müssen nicht wissen, wie die Methoden einer Klasse funktionieren (wenn Sie sie nicht selbst implementiert haben), sondern nur, was sie tun. OOP ist auch nützlich, wenn Sie eine große Anzahl von Objekten desselben Typs in einem System haben: Sie müssen nur die Objekte erstellen und sie dann alle auf dieselbe Weise bearbeiten, ohne Code neu zu schreiben. Darüber hinaus kann ein Objekt seinen Status (Variablenwerte usw.) während der Ausführung des Programms beibehalten.
Die Implementierung von "Car" ist uns verborgen, wir können jedoch die volle Kapazität nutzen.
OOP in PHP
PHP 5 (obwohl die meisten Ideen in diesem Artikel auch für PHP 4 gelten) bietet eine hervorragende Unterstützung für die objektorientierte Programmierung, da es eine einfache Klassenerstellung bietet. PHP bietet jedes Paradigma, das andere "echte" OOP-Sprachen implementieren (z. B. Python und JAVA), wie Vererbung, Polymorphismus und Kapselung.
Erbe
Die Grundidee hinter der Vererbung ist, dass ähnliche Objekte gemeinsame Eigenschaften haben. Wenn wir also eine "generische" Klasse erstellen, können wir einen Entwurf erstellen, auf dem unsere nachfolgenden Klassen aufbauen können. Stellen Sie sich, wenn Sie so wollen, die Eigenschaften eines Autos vor: Farbe, Anzahl der Räder, Leistung, Anzahl der Sitze usw. Mit dieser Vorlage können wir unsere Autos weiter spezialisieren, indem wir diese Klasse erweitern: Erstellen eines Rennwagens mit der Eigenschaft "Nitro" oder eines Lastwagens mit der Eigenschaft "Anhänger". Das Abschluss lautet: Erstellen Sie eine allgemeinere Klasse, die die meisten allgemeinen Attribute enthält, und Sie haben viel weniger Arbeit beim Definieren anderer Objekte, die sich nur geringfügig unterscheiden. Anstatt den gesamten Code neu zu schreiben, erweitern Sie einfach seine Eigenschaften und sparen so viel Zeit.
Vererbungsdiagramm für unsere Fahrzeugklassen.
Verkapselung
Wie bereits erläutert, besteht einer der Hauptvorteile der Verwendung von Objekten darin, dass nicht alle Elemente (Attribute oder Funktionen) angezeigt werden müssen. nur die notwendigen Schnittstellen, um damit zu arbeiten. Details, die für die Verwendung dieser Objekte nicht nützlich sind, sollten vor den übrigen Objekten verborgen bleiben. Dies wird als Kapselung bezeichnet.
Sichtbarkeitsniveau
- public: bedeutet, dass ein Klassenmitglied für alle sichtbar und verwendbar/veränderbar ist
- private: bedeutet, dass ein Klassenmitglied nur von der Klasse selbst verwendet/geändert werden kann
- protected: bedeutet, dass ein Klassenmitglied nur von der Klasse selbst und eventuellen Unterklassen verwendet/geändert werden kann
HINWEIS: In PHP ist ein Klassenmitglied standardmäßig öffentlich, sofern es nicht als privat oder geschützt deklariert ist. Schauen Sie sich hier ein Beispiel an.
Polymorphismus
Polymorphismus ist eine OOP-Eigenschaft, die es dem Programmierer ermöglicht, etwas in verschiedenen Kontexten eine andere Bedeutung oder Verwendung zuzuweisen - insbesondere, damit ein Klassenmitglied je nach verwendetem Kontext unterschiedliche Aufgaben ausführen kann. Stellen Sie sich vor, Sie haben eine Personenklasse und zwei Unterklassen von Personen: Japanisch und Amerikanisch. Beide implementieren eine Funktion namens talk(), jedoch mit unterschiedlichen Sprachen und sozialem Kontext. Und während beide im Grunde genommen Menschen sind (da sie von der Klasse Person abgeleitet sind), ist ihre Implementierung der Funktion talk() sehr unterschiedlich. Sie haben also grundsätzlich zwei Objekte der Klasse Person, in denen die Funktion talk() unterschiedlich funktioniert.
Unsere Hände schmutzig machen
Ok, jetzt zur eigentlichen Aktion. Wir werden eine einfache Klasse für die Bildmanipulation und Informationsextraktion erstellen. Für die Dauer dieses Tutorials gehe ich davon aus, dass Sie ein grundlegendes Verständnis von PHP haben (Variablen, Erstellen von Funktionen, Arbeiten mit Kontrollflussanweisungen und Schleifen). Durch das Lesen des GD PHP-Handbuchs werden alle Zweifel an den Bildbearbeitungsfunktionen beseitigt.
Schritt 1: Erstellen Sie unsere Klasse
Wir beginnen mit der Definition unserer Klasse:
1 |
<?php
|
2 |
class Image { |
3 |
}
|
4 |
?>
|
Dies sagt PHP nur, dass wir anfangen werden, eine neue Klasse mit dem Namen "Image" zu definieren. Jetzt definieren wir den Klassenkonstruktor. Ein Konstruktor ist einfach die Funktion, die beim Erstellen eines neuen Objekts aufgerufen wird. In PHP 5 kann dies durch zwei verschiedene Methoden erreicht werden: Erstellen einer öffentlichen Funktion mit genau demselben Namen der Klasse (PHP 4 und höher) oder durch Erstellen einer Funktion namens "__construct()" (nur PHP 5):
Schritt 2: Erstellen des Klassenkonstruktors
Die folgenden zwei Codeteile machen genau dasselbe:
1 |
<?php
|
2 |
class Image { |
3 |
public function Image() { |
4 |
echo "We just created and object!"; |
5 |
}
|
6 |
}
|
7 |
$image = new Image(); // prints "We just created and object!" |
8 |
?>
|
1 |
<?php
|
2 |
class Image { |
3 |
function __construct() { |
4 |
echo "We just created and object!"; |
5 |
}
|
6 |
}
|
7 |
$image = new Image(); // prints "We just created and object!" |
8 |
?>
|
HINWEIS: Ein Klassenkonstruktor ist immer öffentlich.
Klassenkonstruktoren sollten verwendet werden, um sicherzustellen, dass das erstellte Objekt über eine minimale Datenmenge verfügt, mit der gearbeitet werden kann. in unserem Fall das gewünschte Bild.
Als erstes müssen wir das Bild lesen, unabhängig vom Typ. Derzeit unterstützt die GD-Bibliothek eine Reihe von Bildtypen, z. B. jpg, png, gif, bmp und andere. Wir müssen nur das Bild lesen und den Typ bestimmen.
1 |
<?php
|
2 |
class Image { |
3 |
function __construct($filename) { |
4 |
|
5 |
// read the image file to a binary buffer
|
6 |
$fp = fopen($filename, 'rb') or die("Image '$filename' not found!"); |
7 |
$buf = ''; |
8 |
while(!feof($fp)) |
9 |
$buf .= fgets($fp, 4096); |
10 |
|
11 |
// create image
|
12 |
imagecreatefromstring($buf); |
13 |
}
|
14 |
}
|
15 |
$image = new Image("image.png"); // If everything went well we have now read the image |
16 |
?>
|
Was haben wir also getan? Um das Bild so mühelos wie möglich zu öffnen, verwenden wir beispielsweise die GD-Funktion imagecreatefromstring (die eine binäre Datenfolge als Eingabe verwendet) anstelle von imagecreatefromjpeg, imagecreatefrompng oder imagecreatefromgif.
Wir versuchen also, eine Image-Datei zu öffnen und ihren Dateizeiger auf $fp zuzuweisen und im Fehlerfall die Programmausführung zu beenden.
1 |
$fp = fopen($filename, 'rb') or die("Image '$filename' not found!"); |
Als nächstes erstellen wir eine leere Zeichenfolge, um unsere Daten zu speichern...
1 |
$buf = ''; |
...und lesen Sie die gesamte Datei, indem Sie die gelesenen Daten mit unseren neu erstellten Zeichenfolgeninhalten verknüpfen.
1 |
while(!feof($fp)) |
2 |
$buf .= fgets($fp, 4096); |
Jetzt müssen wir nur noch unser Bild mit den Daten erstellen, die wir gerade gelesen haben...
1 |
imagecreatefromstring($buf); |
...und erstellen Sie ein Objekt, um alle diese Funktionen zu nutzen.
1 |
$image = new Image("image.png"); |
HINWEIS: JPG-, PNG-, GIF- und die meisten Bilddateien müssen im Binärmodus gelesen werden, daher wird das "rb" als zweites Argument der Funktion fopen übergeben. "r" bedeutet schreibgeschützt und "b" bedeutet binär.
Schritt 3: Definieren von Klassenattributen und -methoden
In der aktuellen Form ist unsere Klasse nicht sehr nützlich. Wir werden also einige Attribute und Methoden hinzufügen, um es nützlicher zu machen. Wir beginnen also mit 1: Definieren einiger interner Variablen (beachten Sie die "private" Sichtbarkeitserklärung vor jeder Variablen)
1 |
<?php
|
2 |
class Image { |
3 |
|
4 |
// class atributes (variables)
|
5 |
private $image; |
6 |
private $width; |
7 |
private $height; |
8 |
private $mimetype; |
9 |
|
10 |
function __construct($filename) { |
11 |
|
12 |
// read the image file to a binary buffer
|
13 |
$fp = fopen($filename, 'rb') or die("Image '$filename' not found!"); |
14 |
$buf = ''; |
15 |
while(!feof($fp)) |
16 |
$buf .= fgets($fp, 4096); |
17 |
|
18 |
// create image and assign it to our variable
|
19 |
$this->image = imagecreatefromstring($buf); |
20 |
|
21 |
// extract image information
|
22 |
$info = getimagesize($filename); |
23 |
$this->width = $info[0]; |
24 |
$this->height = $info[1]; |
25 |
$this->mimetype = $info['mime']; |
26 |
}
|
27 |
}
|
28 |
$image = new Image("image.png"); // If everything went well we have now read the image |
29 |
?>
|
Und 2: eine Methode zum Anzeigen des Bildes.
1 |
<?php
|
2 |
class Image { |
3 |
|
4 |
.
|
5 |
.
|
6 |
.
|
7 |
|
8 |
public function display() { |
9 |
header("Content-type: {$this->mimetype}"); |
10 |
switch($this->mimetype) { |
11 |
case 'image/jpeg': imagejpeg($this->image); break; |
12 |
case 'image/png': imagepng($this->image); break; |
13 |
case 'image/gif': imagegif($this->image); break; |
14 |
}
|
15 |
//exit;
|
16 |
}
|
17 |
}
|
18 |
$image = new Image($_GET['image']); // If everything went well we have now read the image |
19 |
?>
|
In diesem Schritt haben wir nur einige Klassenattribute (Bild, Breite, Höhe und Mimetyp) erstellt, um die Daten des Objekts zu speichern. Dann haben wir einige Änderungen vorgenommen, um das erstellte Bild unserem Klassenattribut $image zuzuweisen...
1 |
$this->image = imagecreatefromstring($buf) |
... und extrahierte die Bildinformationen in unsere verbleibenden Klassenvariablen (lesen Sie die Dokumentation zu getimagesize, um vollständig zu verstehen, wie die Bildinformationen gelesen werden):
1 |
// extract image information
|
2 |
$info = getimagesize($filename); |
3 |
$this->width = $info[0]; |
4 |
$this->height = $info[1]; |
5 |
$this->mimetype = $info['mime']; |
Als nächstes haben wir eine Funktion erstellt, die das Bild an den Browser ausgibt, indem wir die entsprechenden Header definieren (lesen Sie mehr über http-Header hier) und die entsprechende Funktion (mit der switch-Anweisung) verwenden, um das Bild basierend auf dem ursprünglichen Bildmimetyp auszugeben (für dieses Tutorial Wir werden nur JPG, PNG und GIF unterstützen, aber wie ich bereits sagte, unterstützt GD eine Vielzahl anderer Formate. Lesen Sie die PHP-Dokumentation für mehr).
Also, was ist das "$this" Zeug da drin? "$this" bezieht sich in PHP auf die Klasse selbst und wird verwendet, um auf Klassenattribute oder -funktionen zu verweisen. Als solches zeigt $this->image auf das Klassenattribut "$image" und $this->image= ... ändert den Wert des Klassenattributs. Wenn Sie $image = ... schreiben würden, würden Sie nur eine neue lokale Variable mit dem Namen "$image" erstellen, die exklusiv für die Dauer der Funktion verfügbar ist. Dies ist eines der wichtigsten Dinge, die beim Erstellen von Klassen in PHP beachtet werden müssen.
Unsere (noch!) Nicht sehr nützliche Anzeigemethode.
Schritt 4: Definieren unserer Unterklasse "Thumbnail"
Im Moment ist unsere Klasse nicht sehr nützlich. Sicher, wir können unser Bild lesen und anzeigen, aber das war's. Wir werden jetzt eine Unterklasse erstellen, um unsere Miniaturansichten zu erstellen. (Wir müssen wirklich keine Unterklasse erstellen, aber wir werden im Interesse des Tutorials Vererbung und Polymorphismus demonstrieren). Damit die Vererbung ordnungsgemäß funktioniert, müssen wir die Definition unserer Superklasse (Image) geringfügig ändern. Wir müssen nur die Sichtbarkeit unserer Klassenvariablen von "private" in "protected" ändern. Und jetzt erstellen wir den Konstruktor unserer Unterklasse.
1 |
<?php
|
2 |
class Image { |
3 |
|
4 |
// class atributes (variables)
|
5 |
protected $image; |
6 |
protected $width; |
7 |
protected $height; |
8 |
protected $mimetype; |
9 |
|
10 |
.
|
11 |
.
|
12 |
.
|
13 |
}
|
14 |
|
15 |
class Thumbnail extends Image { |
16 |
|
17 |
function __construct($image, $width, $height) { |
18 |
|
19 |
// call the super-class contructor
|
20 |
parent::__construct($image); |
21 |
|
22 |
// modify the image to create a thumbnail
|
23 |
$thumb = imagecreatetruecolor($width, $height); |
24 |
imagecopyresampled($thumb, $this->image, 0, 0, 0, 0, $width, $height, $this->width, $this->height); |
25 |
$this->image = $thumb; |
26 |
}
|
27 |
}
|
28 |
?>
|
Was genau machen wir hier? Wir haben eine neue Klasse erstellt, die von unserem Original abgeleitet ist. Dies bedeutet, dass wir auf alle öffentlichen und geschützten Attribute und Methoden zugreifen können. Wir nennen den Superklassenkonstruktor, der für das Lesen des Bildes und das Extrahieren seiner Informationen verantwortlich ist. Der Unterklassenkonstruktor ruft seinen Oberklassenkonstruktor nicht auf, daher müssen wir ihn explizit aufrufen.
Jetzt erstellen wir ein neues Bild für unser Miniaturbild mit der übergebenen Breite und Höhe:
1 |
$thumb = imagecreatetruecolor($width, $height); |
Ändern Sie die Größe des Originalbilds in das neue, um die Miniaturansicht zu erstellen:
1 |
imagecopyresampled($thumb, $this->image, 0, 0, 0, 0, $width, $height, $this->width, $this->height); |
Und schließlich ändern Sie das Originalbild so, dass es das Miniaturbild anstelle des Bilds in voller Größe enthält:
1 |
$this->image = $thumb; |
Und rate was? Wir müssen nicht wirklich eine neue Funktion schreiben, um das Miniaturbild anzuzeigen, da das gleiche Prinzip gilt, unabhängig davon, ob Sie ein Bild in voller Größe oder ein Miniaturbild anzeigen. Immerhin ist es immer noch ein Bild! Wir müssen also nur unsere display()-Funktion aufrufen, die in der Superklasse definiert ist, und fertig!
Unsere abgeschlossene Klasse und die jeweilige Unterklasse.
Damit ist unser Tutorial abgeschlossen. Als Übung schlage ich vor, dass Sie eine Funktion implementieren, um die generierten Miniaturansichten auf der Festplatte zu speichern, anstatt sie im laufenden Betrieb auszugeben (Wo sollten Sie diese Funktion implementieren? In der Super- oder Unterklasse?). Viel Glück und überprüfen Sie die bereitgestellte Zip-Datei für eine Beispielverwendung und die hier entwickelten vollständigen Klassen (Sie benötigen einen PHP-Server, um sie zu testen).
- Abonnieren Sie den NETTUTS RSS Feed für weitere tägliche Webentwicklungs-Tuts und Artikel.
