Objektorientierte Programmierung mit PHP5

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Objektorientierte Programmierung mit PHP5

    [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
    [tabmenu]
    [tab='Werbung in eigener Sache']
    Du suchst einen Instant Messenger dessen Verbindung voll verschlüsselt ist? Weiterhin soll er mit anderen Instant Massenging Protokollen verknüpfbar sein? Außerdem möchtest du weltweit erreichbar sein (ähnlich icq und msn)? - Dann schick mir Post und erhalte ein unverbindliches, auf alle Fälle kostenloses, Angebot:
    [IMG:http://easy-scripting.net/icon/vCollection/pmEmptyS.png]
    [tab='Vorstellung']
    NurPech
    [tab='meine Tutorials']
    [subtab='C#']

    [subtab='PHP']

    [/tabmenu]

    Meinungen, die ich geäußert habe, sind nicht notwendigerweise meine eigenen. Abweichungen von der deutschen Rechtschreibung unterliegen dem Urheberrecht, dürfen aber unter den Bedingungen von [IMG:http://i.creativecommons.org/l/by-nc-nd/3.0/80x15.png] verwendet werden

    Dieser Beitrag wurde bereits 17 mal editiert, zuletzt von NurPech ()

  • 1. Was ist objektorientierte Programmierung?

    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:

    PHP-Quellcode

    1. <?php
    2. $array = array(1,2,3,4,5,6,7,8,9,10);
    3. foreach($array AS $key=>$value) {
    4. if($key == 3) {
    5. $value = 10;
    6. }
    7. echo $value . '<br />';
    8. }
    9. ?>


    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.
    [tabmenu]
    [tab='Werbung in eigener Sache']
    Du suchst einen Instant Messenger dessen Verbindung voll verschlüsselt ist? Weiterhin soll er mit anderen Instant Massenging Protokollen verknüpfbar sein? Außerdem möchtest du weltweit erreichbar sein (ähnlich icq und msn)? - Dann schick mir Post und erhalte ein unverbindliches, auf alle Fälle kostenloses, Angebot:
    [IMG:http://easy-scripting.net/icon/vCollection/pmEmptyS.png]
    [tab='Vorstellung']
    NurPech
    [tab='meine Tutorials']
    [subtab='C#']

    [subtab='PHP']

    [/tabmenu]

    Meinungen, die ich geäußert habe, sind nicht notwendigerweise meine eigenen. Abweichungen von der deutschen Rechtschreibung unterliegen dem Urheberrecht, dürfen aber unter den Bedingungen von [IMG:http://i.creativecommons.org/l/by-nc-nd/3.0/80x15.png] verwendet werden

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von NurPech ()

  • 2. Klassen, Objekte und Methoden

    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

    PHP-Quellcode

    1. class
    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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. }
    4. ?>
    Um die Klasse nun nutzen zu können, müssen wir erst ein Objekt der Klasse erzeugen. Dies funktioniert mit dem Schlüsselwort

    PHP-Quellcode

    1. new
    gefolgt von dem Klassennamen und einer runden Klammer welche direkt wieder geschlossen wird:

    PHP-Quellcode

    1. <?php
    2. $meinAuto = new Auto();
    3. ?>
    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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. //Methoden
    8. public function fahren() {
    9. echo 'Unser Auto fährt';
    10. }
    11. }
    12. ?>
    Alles anzeigen
    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:

    PHP-Quellcode

    1. <?php
    2. $meinAuto = new Auto();
    3. $meinAuto->farbe = 'blau';
    4. $meinAuto->hoechstgeschwindigkeit = 180;
    5. $meinAuto->sitzanzahl = 5;
    6. $meinAuto->fahren();
    7. ?>
    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.

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von NurPech ()

  • 3. Paamayim Nekudotayim

    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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. //Methoden
    8. public function fahren() {
    9. echo 'Unser Auto fährt';
    10. }
    11. }
    12. $meinAuto = new Auto();
    13. $meinAuto->farbe = 'blau';
    14. $meinAuto->hoechstgeschwindigkeit = 180;
    15. $meinAuto->sitzanzahl = 5;
    16. $meinAuto->fahren();
    17. ?>
    Alles anzeigen
    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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. public $verkauft = 0;
    8. //Methoden
    9. public function fahren() {
    10. echo 'Unser Auto fährt';
    11. }
    12. }
    13. $meinAuto = new Auto();
    14. $meinAuto->verkauft++;
    15. $meinAuto2 = new Auto();
    16. $meinAuto2->verkauft++;
    17. $meinAuto->farbe = 'blau';
    18. $meinAuto->hoechstgeschwindigkeit = 180;
    19. $meinAuto->sitzanzahl = 5;
    20. $meinAuto->fahren();
    21. ?>
    Alles anzeigen
    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

    PHP-Quellcode

    1. static
    Unsere Klasse sieht also wie folgt aus:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. public static $verkauft = 0;
    8. //Methoden
    9. public function fahren() {
    10. echo 'Unser Auto fährt';
    11. }
    12. }
    13. ?>
    Alles anzeigen
    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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. public static $verkauft = 0;
    8. //Methoden
    9. public function fahren() {
    10. echo 'Unser Auto fährt';
    11. }
    12. }
    13. $meinAuto = new Auto();
    14. Auto::$verkauft++;
    15. $meinAuto2 = new Auto();
    16. Auto::$verkauft++;
    17. $meinAuto->farbe = 'blau';
    18. $meinAuto->hoechstgeschwindigkeit = 180;
    19. $meinAuto->sitzanzahl = 5;
    20. $meinAuto->fahren();
    21. ?>
    Alles anzeigen
    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.

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. public static $verkauft = 0;
    8. //Methoden
    9. public function fahren() {
    10. echo 'Unser Auto fährt';
    11. }
    12. public function holeVerkaufteAnzahl() {
    13. echo Auto::$verkauft;
    14. }
    15. }
    16. $meinAuto = new Auto();
    17. Auto::$verkauft++;
    18. $meinAuto2 = new Auto();
    19. Auto::$verkauft++;
    20. $meinAuto->farbe = 'blau';
    21. $meinAuto->hoechstgeschwindigkeit = 180;
    22. $meinAuto->sitzanzahl = 5;
    23. $meinAuto->fahren();
    24. $meinAuto->holeVerkaufteAnzahl();
    25. $meinAuto2->holeVerkaufteAnzahl();
    26. ?>
    Alles anzeigen
    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.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von NurPech ()

  • 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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. public static $verkauft = 0;
    8. //Methoden
    9. public function fahren() {
    10. echo 'Unser Auto fährt maximal '.$this->hoechstgeschwindigkeit;
    11. }
    12. public function holeVerkaufteAnzahl() {
    13. echo self::$verkauft;
    14. }
    15. }
    16. $meinAuto = new Auto();
    17. Auto::$verkauft++;
    18. $meinAuto2 = new Auto();
    19. Auto::$verkauft++;
    20. $meinAuto->farbe = 'blau';
    21. $meinAuto->hoechstgeschwindigkeit = 180;
    22. $meinAuto->sitzanzahl = 5;
    23. $meinAuto->fahren();
    24. $meinAuto->holeVerkaufteAnzahl();
    25. $meinAuto2->holeVerkaufteAnzahl();
    26. ?>
    Alles anzeigen
    Beim Aufruf der Methode fahren() wird uns nun mitgeteilt wie schnell das Auto maximal fahren kann.

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von NurPech ()

  • 5. Magische Methoden

    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

    PHP-Quellcode

    1. __construct() {
    2. }
    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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. public static $verkauft = 0;
    8. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl) {
    9. $this->farbe = $farbe;
    10. $this->hoechstgeschwindigkeit = $hoechstgeschwindigkeit;
    11. $this->sitzanzahl = $sitzanzahl;
    12. self::$verkauft++;
    13. }
    14. //Methoden
    15. public function fahren() {
    16. echo 'Unser Auto fährt maximal '.$this->hoechstgeschwindigkeit;
    17. }
    18. public function holeVerkaufteAnzahl() {
    19. echo self::$verkauft;
    20. }
    21. }
    22. $meinAuto = new Auto('blau', 180, 5);
    23. $meinAuto2 = new Auto('schwarz', 210, 2);
    24. $meinAuto->fahren();
    25. $meinAuto->holeVerkaufteAnzahl();
    26. $meinAuto2->holeVerkaufteAnzahl();
    27. ?>
    Alles anzeigen


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

    Der Destruktor ist das genaue Gegenteil den Konstruktors. Entsprechend wird er implementiert:

    PHP-Quellcode

    1. __destruct() {
    2. }
    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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. public static $verkauft = 0;
    8. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl) {
    9. $this->farbe = $farbe;
    10. $this->hoechstgeschwindigkeit = $hoechstgeschwindigkeit;
    11. $this->sitzanzahl = $sitzanzahl;
    12. self::$verkauft++;
    13. }
    14. public function __destruct() {
    15. echo 'Zerstöre Objekt';
    16. }
    17. //Methoden
    18. public function fahren() {
    19. echo 'Unser Auto fährt maximal '.$this->hoechstgeschwindigkeit;
    20. }
    21. public function holeVerkaufteAnzahl() {
    22. echo self::$verkauft;
    23. }
    24. }
    25. $meinAuto = new Auto('blau', 180, 5);
    26. $meinAuto2 = new Auto('schwarz', 210, 2);
    27. $meinAuto->fahren();
    28. $meinAuto->holeVerkaufteAnzahl();
    29. $meinAuto2->holeVerkaufteAnzahl();
    30. ?>
    Alles anzeigen
    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:

    PHP-Quellcode

    1. <?php
    2. public function __autoload($class) {
    3. require_once($class.'class.php');
    4. }
    5. ?>
    Auf unser Beispiel bezogen sieht das Ganze so aus: Wir lagern unsere Klasse in die Datei Auto.class.php aus:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. public static $verkauft = 0;
    8. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl) {
    9. $this->farbe = $farbe;
    10. $this->hoechstgeschwindigkeit = $hoechstgeschwindigkeit;
    11. $this->sitzanzahl = $sitzanzahl;
    12. self::$verkauft++;
    13. }
    14. public function __destruct() {
    15. echo 'Zerstöre Objekt';
    16. }
    17. //Methoden
    18. public function fahren() {
    19. echo 'Unser Auto fährt maximal '.$this->hoechstgeschwindigkeit;
    20. }
    21. public function holeVerkaufteAnzahl() {
    22. echo self::$verkauft;
    23. }
    24. }
    25. ?>
    Alles anzeigen
    Entsprechend unsere index.php:

    PHP-Quellcode

    1. <?php
    2. function __autoload($class) {
    3. require_once($class.'class.php');
    4. }
    5. $meinAuto = new Auto('blau', 180, 5);
    6. $meinAuto2 = new Auto('schwarz', 210, 2);
    7. $meinAuto->fahren();
    8. $meinAuto->holeVerkaufteAnzahl();
    9. $meinAuto2->holeVerkaufteAnzahl();
    10. ?>
    Alles anzeigen
    [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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $farbe;
    5. public $hoechstgeschwindigkeit;
    6. public $sitzanzahl;
    7. public static $verkauft = 0;
    8. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl) {
    9. $this->farbe = $farbe;
    10. $this->hoechstgeschwindigkeit = $hoechstgeschwindigkeit;
    11. $this->sitzanzahl = $sitzanzahl;
    12. self::$verkauft++;
    13. }
    14. public function __destruct() {
    15. echo 'Zerstöre Objekt';
    16. }
    17. public function __toString() {
    18. return 'Unser Auto fährt maximal '.$this->hoechstgeschwindigkeit;
    19. }
    20. //Methoden
    21. public function fahren() {
    22. echo 'Unser Auto fährt maximal '.$this->hoechstgeschwindigkeit;
    23. }
    24. public function holeVerkaufteAnzahl() {
    25. echo self::$verkauft;
    26. }
    27. }
    28. ?>
    Alles anzeigen
    Und unsere index.php:

    PHP-Quellcode

    1. <?php
    2. function __autoload($class) {
    3. require_once($class.'class.php');
    4. }
    5. $meinAuto = new Auto('blau', 180, 5);
    6. $meinAuto2 = new Auto('schwarz', 210, 2);
    7. $meinAuto->fahren();
    8. $meinAuto->holeVerkaufteAnzahl();
    9. $meinAuto2->holeVerkaufteAnzahl();
    10. echo $meinAuto;
    11. ?>
    Alles anzeigen

    [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:

    PHP-Quellcode

    1. <?php
    2. class Auto {
    3. //Attribute
    4. public $data = array();
    5. public static $verkauft = 0;
    6. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl) {
    7. $this->data['farbe'] = $farbe;
    8. $this->data['hoechstgeschwindigkeit'] = $hoechstgeschwindigkeit;
    9. $this->data['sitzanzahl'] = $sitzanzahl;
    10. self::$verkauft++;
    11. }
    12. public function __destruct() {
    13. echo 'Zerstöre Objekt';
    14. }
    15. public function __toString() {
    16. return 'Unser Auto fährt maximal '.$this->hoechstgeschwindigkeit;
    17. }
    18. public function __get($var) {
    19. if(isset($this->data[$var])) {
    20. return $this->data[$var];
    21. }
    22. return null;
    23. }
    24. //Methoden
    25. public function fahren() {
    26. echo 'Unser Auto fährt maximal '.$this->hoechstgeschwindigkeit;
    27. }
    28. public function holeVerkaufteAnzahl() {
    29. echo self::$verkauft;
    30. }
    31. }
    32. ?>
    Alles anzeigen

    [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]

    Dieser Beitrag wurde bereits 14 mal editiert, zuletzt von NurPech ()

  • 6. Polymorphie

    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:

    PHP-Quellcode

    1. <?php
    2. class Kraftwagen {
    3. //Attribute
    4. public $data = array();
    5. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl) {
    6. $this->data['farbe'] = $farbe;
    7. $this->data['hoechstgeschwindigkeit'] = $hoechstgeschwindigkeit;
    8. $this->data['sitzanzahl'] = $sitzanzahl;
    9. }
    10. public function __destruct() {
    11. echo 'Zerstöre Objekt';
    12. }
    13. //Methoden
    14. public function fahren() {
    15. echo 'Unser Kraftwagen fährt maximal '.$this->['hoechstgeschwindigkeit'];
    16. }
    17. }
    18. class LKW extends Kraftwagen {
    19. }
    20. class PKW extends Kraftwagen {
    21. }
    22. ?>
    23. <?php
    24. $meinPKW = new PKW('blau', 180, 5);
    25. $meinLKW = new LKW('schwarz', 100, 2);
    26. $meinPKW->fahren();
    27. ?>
    Alles anzeigen
    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:

    PHP-Quellcode

    1. <?php
    2. class Kraftwagen {
    3. //Attribute
    4. public $data = array();
    5. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl) {
    6. $this->data['farbe'] = $farbe;
    7. $this->data['hoechstgeschwindigkeit'] = $hoechstgeschwindigkeit;
    8. $this->data['sitzanzahl'] = $sitzanzahl;
    9. }
    10. public function __destruct() {
    11. echo 'Zerstöre Objekt';
    12. }
    13. //Methoden
    14. public function fahren() {
    15. echo 'Unser Kraftwagen fährt maximal '.$this->data['hoechstgeschwindigkeit'];
    16. }
    17. }
    18. class LKW extends Kraftwagen {
    19. public $firma = '';
    20. }
    21. class PKW extends Kraftwagen {
    22. public $halter = '';
    23. }
    24. ?>
    25. <?php
    26. $meinPKW = new PKW('blau', 180, 5);
    27. $meinLKW = new LKW('schwarz', 100, 2);
    28. $meinPKW->halter = 'Max Mustermann';
    29. $meinLKW->firma = 'Max Mustermann AG';
    30. $meinPKW->fahren();
    31. ?>
    Alles anzeigen
    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:

    PHP-Quellcode

    1. parent::myMethod()
    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:

    PHP-Quellcode

    1. <?php
    2. class Kraftwagen {
    3. //Attribute
    4. public $data = array();
    5. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl) {
    6. $this->data['farbe'] = $farbe;
    7. $this->data['hoechstgeschwindigkeit'] = $hoechstgeschwindigkeit;
    8. $this->data['sitzanzahl'] = $sitzanzahl;
    9. }
    10. public function __destruct() {
    11. echo 'Zerstöre Objekt';
    12. }
    13. //Methoden
    14. public function fahren() {
    15. echo 'Unser Kraftwagen fährt maximal '.$this->data['hoechstgeschwindigkeit'];
    16. }
    17. }
    18. class LKW extends Kraftwagen {
    19. public $firma = '';
    20. public $ladeflaeche = 0;
    21. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl, $ladeflaeche) {
    22. $this->ladeladeflaeche = $ladeladeflaeche;
    23. parent::__construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl);
    24. }
    25. }
    26. class PKW extends Kraftwagen {
    27. public $halter = '';
    28. }
    29. ?>
    30. <?php
    31. $meinPKW = new PKW('blau', 180, 5);
    32. $meinLKW = new LKW('schwarz', 100, 2, 10);
    33. $meinPKW->halter = 'Max Mustermann';
    34. $meinLKW->firma = 'Max Mustermann AG';
    35. $meinPKW->fahren();
    36. ?>
    Alles anzeigen
    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.
    [tabmenu]
    [tab='Werbung in eigener Sache']
    Du suchst einen Instant Messenger dessen Verbindung voll verschlüsselt ist? Weiterhin soll er mit anderen Instant Massenging Protokollen verknüpfbar sein? Außerdem möchtest du weltweit erreichbar sein (ähnlich icq und msn)? - Dann schick mir Post und erhalte ein unverbindliches, auf alle Fälle kostenloses, Angebot:
    [IMG:http://easy-scripting.net/icon/vCollection/pmEmptyS.png]
    [tab='Vorstellung']
    NurPech
    [tab='meine Tutorials']
    [subtab='C#']

    [subtab='PHP']

    [/tabmenu]

    Meinungen, die ich geäußert habe, sind nicht notwendigerweise meine eigenen. Abweichungen von der deutschen Rechtschreibung unterliegen dem Urheberrecht, dürfen aber unter den Bedingungen von [IMG:http://i.creativecommons.org/l/by-nc-nd/3.0/80x15.png] verwendet werden

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von NurPech ()

  • 7. Sichtbarkeit

    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:

    PHP-Quellcode

    1. <?php
    2. class Kraftwagen {
    3. //Attribute
    4. private $data = array();
    5. protected $halter = '';
    6. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl, $halter) {
    7. $this->data['farbe'] = $farbe;
    8. $this->data['hoechstgeschwindigkeit'] = $hoechstgeschwindigkeit;
    9. $this->data['sitzanzahl'] = $sitzanzahl;
    10. }
    11. public function __destruct() {
    12. echo 'Zerstöre Objekt';
    13. }
    14. //Methoden
    15. public function fahren() {
    16. echo 'Unser Kraftwagen fährt maximal '.$this->data['hoechstgeschwindigkeit'];
    17. }
    18. protected function getData() {
    19. return $this-data;
    20. }
    21. }
    22. class LKW extends Kraftwagen {
    23. private $ladeflaeche = 0;
    24. public function __construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl, $ladeflaeche, $halter) {
    25. $this->ladeladeflaeche = $ladeladeflaeche;
    26. parent::__construct($farbe, $hoechstgeschwindigkeit, $sitzanzahl, $halter);
    27. }
    28. }
    29. class PKW extends Kraftwagen {
    30. public function getHalter() {
    31. return $this->halter;
    32. }
    33. public function getFarbe() {
    34. $data = parent::getData();
    35. return $data['farbe'];
    36. }
    37. }
    38. ?>
    Alles anzeigen


    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!

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von NurPech ()