[PHP] OOP mit PHP4 (Grundlagen + Meine erste Klasse + Theorie OOP sowie Trennung Code-HTML)

Dieses Thema im Forum "Webentwicklung" wurde erstellt von Flyde, 8. August 2008 .

  1. 8. August 2008
    OOP mit PHP4 (Grundlagen + Meine erste Klasse + Theorie OOP sowie Trennung Code-HTML)

    Hi, ich hab mich hier in der Sektion ein wenig umgeschaut und gesehen das es zwar viele Tuts gibt - aber wenige die sich wirklich mit den Grundlagen beschäftigen was OOP angeht.

    Hinweis: OOP = Objekt Orientierte Programmierung

    Falls beim lesen Fragen auftauchen, schreibt mir eine PM.
    Bei Verbesserungsvorschlägen ebenfalls, ich bin auch nicht perfekt

    So, erstmal zu den Voraussetzungen:
    - Ihr solltet mit dem Umgang von Variablen, Schleifen sowie Funktionen vertraut sein.
    - Ihr solltet einen Webserver mit PHP oder einen lokalen Apache (http://www.apachefriends.org/de/index.html) installieren, um selbst ein wenig rum zu experimentieren, denn vom puren lesen wird man aus der Sache auch nicht schlau.
    - Das Wichtigste: Ihr solltet Motivation mitbringen und ebenfalls jeden gefundenen Rechtschreibfehler als Geschenk von mir behalten


    Ein wenig Theorie (so leid es mir tut ):

    Wer C++ programmiert, hat das Problem erst garnicht, es verfolgt jeden PHP'ler auf kurz oder lang der ein größeres Projekt plant: Die allgemeine Übersicht über den eigenen Quellcode.
    Ein gut gepflegter Quellcode weisst viele Vorteile auf, unteranderem:
    1. Übersicht
    2. Schnelleres finden von Bugs die IMMER entstehen
    3. Logischere Zusammenhänge erstellen (Z.B. die Klasse "Login" mit der Methode "JetztEinloggen" ruft innerhalb der Methode "LoginPruefen" auf)

    Hinweis: Die normalen Funktionen, die ihr kennt, heißen in OOP Methoden.
    Ebenfalls heißen Variablen in OOP Attribute

    Im allgemeinen finde ich das beste Feature in OOP die Verschachtelung bzw. die wirklich logisch aufbaubare Struktur (sofern man es denn so will und auch durchzieht)

    Zu beachten ist ebenfalls die Struktur der Ordner und Dateinamen.
    Ich für meinen Geschmack lege für jedes neue Projekt folgende Struktur an:
    • system/ (hier alle Klassen rein)
    • system/class.[klassenname].php - Muss nicht so sein... ist mein Stil
    • img/
    • scripts/ - CSS/JS Files
    • templates/ - Htmlfiles

    Ist noch nicht alles, geht aber auch eh nicht um das Thema, wollte nur damit anmerken, das auch eine Ordnerstruktur nicht zu vernachlässigen ist.

    So, ich will die Theorie auch nicht all zu lang ziehen also nun zum praktischen Teil:

    Vorbereitung:
    • Erstellt eine index.php im Root-Verzeichnis (Root = Haupt-...)
    • erstellt einen Unterordner mit dem namen Klassen und wiederum dort eine Datei: class.template.php
    • erstellt einen Unterordner "templates/" und erstellt dort eine index.htm
      class.template.php

    Hinweis: Meine Klasse "class.template.php" wird genutzt, um HTML-Datein zu laden und deren Inhalt zu manipulieren (dynamisch zu machen).
    Dieses Beispiel nehme ich, um euch gleichzeitig noch den Wert einer Trennung von HTML und Script mitzugeben.

    1. class.template.php
    1.1 Erstellung einer Klasse

    Eine Klasse wird mit einem "class KLASSENNAME {" begonnen und hört mit einem "}" auf.
    Wichtige Hinweise: An die c++ oop'ler: Die Klasse wird nicht mit "};" geschlossen.
    An alle: nach dem Klassenname kommen keine "()" denn die Klasse selbst ist keine Methode. Nur Methoden haben "()" und ihnen können auch nur Attribute übergeben werden.

    Quellcode class.template.php
    PHP:
    class  tpl  // tpl = abkürzung für Template, mag zu lange Klassennamen nicht so...
    // ...
    }
    Nun habt ihr quasi eine Kiste gebaut, die eine Beschriftung hat. In diese Kiste fehlt nun noch Inhalt.

    1.2. Überlegungen zur Klasse und deren Methoden


    Ich hab mehrere Methoden in dieser Klasse aber pick für das Tutorial nurmal die Wichtigsten und sinnvollsten raus.

    • loadHTML() // Wird genutzt um eine HTML-Datei zu "laden"
    • loadContent($html_file) // Wird genutzt, um die HTML-Datei zu bearbeiten und sie Content-Bereit zu machen
    • Ausgeben() // Simples echo zum Ausgeben der geladenen HTML-Seite

    Nun müssen wir noch überlegen, welche Attribute wir für die ganze Klasse und welche wir nur für eine Methode benötigen.
    In meiner erstellten Klasse habe ich folgende Attribute:
    • $tplpfad = "templates/"

    Viele, oder? Naja, mehr brauch ich auch erstmal nicht (Habe für andere Methoden noch ein paar Variablen in denen ich für eine jeweilige HTML-Seite die Beschreibung sowie Seitentitel etc. speichere)

    1.3 Erstellung der Methoden

    Nicht erschrecken: Hier erst mal der komplette Quelltext.
    Ich werde ihn noch stück für stück auseinander nehmen.

    Quellcode class.template.php
    PHP:
    <? php
    class  tpl
    {
            var 
    $tpldir  "templates/" // Speichert den Pfad zu den HTML-Files
            
            
    function  loadContent ( $html_file // Lädt die übergebene HTML-Datei
            
    {
                    
    $content  $this -> loadHTML ( $html_file );
                    
                    
    // Ordnerpfade [Dienen rein als Beispiel, wie man so recht einfach dauerhaft das gleiche in Datein eintragen muss ohne sich den finger wund zu "strg+v"'en]
                    
    $content  str_replace ( "{css_path}" "scripte/" $content );  // CSS Pfad
                    // -----------
                    
                    
    $content  str_replace ( "{seitentitel}" "Meine erste Klasse - sie funktioniert :)" $content );
                    
                    return 
    $content // Gibt den Inhalt (man erwähne: Manipuliert durch str_replace) zurück. (Zweck sieht man später in der index.php)            
            
    }
            
            function 
    loadHTML ( $parFile // Lädt eine HTML-Datei als Template
            
    {
                    if(!
    $pTpl  file_get_contents ( $this -> tpldir . $parFile )) {  // Invertierte Abfrage, ob die if-schleife false ist.
                            
    echo  "Konnte Seite nicht laden, Datei nicht gefunden." // Kleiner Fehlerbericht..
                            
    return  false // Stoppt den Prozess der Methode. Somit ist return $pTpl; ausgeschlossen
                    
    }
                    
                    return 
    $pTpl // Gibt $pTpl an $content aus "loadContent" zurück. Somit ist der Inhalt nun im Attribut gespeichert und fertig zum bearbeiten.
            
    }
            
            function 
    Ausgeben ( $parTPL )
            {
                    echo 
    $parTPL // Methode wird dort eingesetzt, wo der Inhalt später mal ausgegeben wird.
                    /* 
                    Wenn man diese Klasse ein wenig erweitern würde, könnte man z.B. eine index.html laden, man lädt eine zweite html datei und lässt den Inhalt der zweiten html in die erste reinsetzen (druch str_replace)
                    Beispiel: $content = str_replace("{meinSeitenInhalt}", $MeinInhalt, $content); */
            
    }
    }
    ?>
    Zwischenstand: Ich schreibe schon 40-60 min und bin erledigt.. aber ich halte tapfer durch *g*

    Back2Topic...

    Lest euch ruhig schon einmal die Kommentare durch und Versucht ein wenig die Logik der Klasse zu verstehen. Ich weiß nicht, ob diese Klasse gut ist, ich kann nur sehr gut mit ihr arbeiten... habe mir auch nur alles selbst bei gebracht und dadurch kann es durchaus zu stilfehlern kommen

    So, zur ersten Methode:
    PHP:
             function  loadContent ( $html_file // Lädt die übergebene HTML-Datei
            
    {
                    
    $content  $this -> loadHTML ( $html_file );
                    
                    
    // Ordnerpfade [Dienen rein als Beispiel, wie man so recht einfach dauerhaft das gleiche in Datein eintragen muss ohne sich den finger wund zu "strg+v"'en]
                    
    $content  str_replace ( "{css_path}" "scripte/" $content );  // CSS Pfad
                    // -----------
                    
                    
    $content  str_replace ( "{seitentitel}" "Meine erste Klasse - sie funktioniert :)" $content );
                    
                    return 
    $content // Gibt den Inhalt (man erwähne: Manipuliert durch str_replace) zurück. (Zweck sieht man später in der index.php)            
            
    }
    Funktionen in OOP werden genauso geschrieben (vom Gerüst) wie außerhalb von OOP.
    function NAME(Übergabewerte) { Inhalt }

    Unterschied: die Klasse kann sich untereinander "verständigen".
    D.h. Ihr könnt Methodenübergreifend Programmieren wie z.b. die Zeile
    PHP:
    $content  $this -> loadHTML ( $html_file );
    Die genauere Bedeutung von loadHTML erkläre ich danach. Erst einmal betrachten wir uns, wie wir diese Methode innerhalb von loadContent aufgerufen haben.

    "$this" steht für "innerhalb der klasse". $this wird quasi ersetzt durch "$tpl".
    Mit dem "->" ruft man Attribute oder Methoden auf - in diesem Fall eine Methode.

    Quasi: $this[$tpl]->loadHTML($html_file); // $html_file haben wir von loadContent übergeben bekommen und geben es direkt weiter an loadHTML.

    Zweck: Man muss in der index.php nicht extra beide Methoden aufrufen aber dazu später noch mehr.
    Die Funktion dieser Methode wird in den Kommentaren beschrieben.

    Zur nächsten Methode
    PHP:
             function  loadHTML ( $parFile // Lädt eine HTML-Datei als Template
            
    {
                    if(!
    $pTpl  file_get_contents ( $this -> tpldir . $parFile )) {  // Invertierte Abfrage, ob die if-schleife false ist.
                            
    echo  "Konnte Seite nicht laden, Datei nicht gefunden." // Kleiner Fehlerbericht..
                            
    return  false // Stoppt den Prozess der Methode. Somit ist return $pTpl; ausgeschlossen
                    
    }
                    
                    return 
    $pTpl // Gibt $pTpl an $content aus "loadContent" zurück. Somit ist der Inhalt nun im Attribut gespeichert und fertig zum bearbeiten.
            
    }
    Gehen wir etwas genauer auf diese Zeile ein: if(!$Tpl = file_get_contents($this->tpldir.$parFile))

    Mit "negiert" meine ich, die If-Abfrage geht direkt davon aus NUR wenn ein Fehler entsteht, führe ich den Code aus. Logischer Code wäre quasi: Falls !$tpl[negiert zu Falls nicht..] = ..der Inhalt von meiner funktion in $tpl gekommen ist... { Gebe fehler aus }

    Zusätzlich sehen wir hier ein Attribut, das innerhalb der Methode angesprochen wird: $this->tpldir, in ihr steht "templates/". Also ist die If-Abfrage if !$tpl = file_get_contents("templates/meinedatei")

    Das zurückgeben von Werten mittels "return" ist in OOP sehr wichtig.
    Durch loadHTML wird eine HTML-Datei geladen, diese Methode wird in loadContent aufgerufen und der "inhalt" von loadHTML in das Attribut $content von loadContent geschmissen (weil loadHTML die geladene HTML mittels return an loadContent bzw. $content gibt)

    Hoffe das war soweit verständlich...

    Die letzte Methode ist denk ich mal verständlich.
    Dort wird einfach in der index.php der Inhalt ausgegeben.

    1.4 Die index.php

    Quellcode Index.php
    PHP:
    <? php
    include( "Klassen/class.template.php" );

    $meineKlasse  = new  tpl ();  // Klasse wird Initialisiert in $meineKlasse. Wird benötigt um die Klasse bekannt zu machen und um mit der angegebenen Variable die Methoden auf zu rufen.

    // Methoden ruft man fast genau wie innerhalb von Klassen auf...
    $HierSpeicherIchMeinenInhalt  $meineKlasse -> loadContent ( "index.htm" );  // Mit dem unterschied, das man hier nicht $this-> schreiben kann, da es außerhalb der Klasse ist.


    $HierSpeicherIchMeinenInhalt  str_replace ( "{weissdergeier}" "Mein neuer Inhalt" $HierSpeicherIchMeinenInhalt );

    // Nun zur Ausgabe
    $meineKlasse -> Ausgeben ( $HierSpeicherIchMeinenInhalt );
    ?>
    Erklärung in den Kommentaren...

    1.5 Zusammenfassung der Quelltexte

    class.template.php
    PHP:
    <? php
    class  tpl
    {
            var 
    $tpldir  "templates/" // Speichert den Pfad zu den HTML-Files
            
            
    function  loadContent ( $html_file // Lädt die übergebene HTML-Datei
            
    {
                    
    $content  $this -> loadHTML ( $html_file );
                    
                    
    // Ordnerpfade [Dienen rein als Beispiel, wie man so recht einfach dauerhaft das gleiche in Datein eintragen muss ohne sich den finger wund zu "strg+v"'en]
                    
    $content  str_replace ( "{css_path}" "scripte/" $content );  // CSS Pfad
                    // -----------
                    
                    
    $content  str_replace ( "{seitentitel}" "Meine erste Klasse - sie funktioniert :)" $content );
                    
                    return 
    $content // Gibt den Inhalt (man erwähne: Manipuliert durch str_replace) zurück. (Zweck sieht man später in der index.php)            
            
    }
            
            function 
    loadHTML ( $parFile // Lädt eine HTML-Datei als Template
            
    {
                    if(!
    $pTpl  file_get_contents ( $this -> tpldir . $parFile )) {  // Invertierte Abfrage, ob die if-schleife false ist.
                            
    echo  "Konnte Seite nicht laden, Datei nicht gefunden." // Kleiner Fehlerbericht..
                            
    return  false // Stoppt den Prozess der Methode. Somit ist return $pTpl; ausgeschlossen
                    
    }
                    
                    return 
    $pTpl // Gibt $pTpl an $content aus "loadContent" zurück. Somit ist der Inhalt nun im Attribut gespeichert und fertig zum bearbeiten.
            
    }
            
            function 
    Ausgeben ( $parTPL )
            {
                    echo 
    $parTPL // Methode wird dort eingesetzt, wo der Inhalt später mal ausgegeben wird.
                    /* 
                    Wenn man diese Klasse ein wenig erweitern würde, könnte man z.B. eine index.html laden, man lädt eine zweite html datei und lässt den Inhalt der zweiten html in die erste reinsetzen (druch str_replace)
                    Beispiel: $content = str_replace("{meinSeitenInhalt}", $MeinInhalt, $content); */
            
    }
    }
    ?>
    index.php
    PHP:
    <? php
    include( "Klassen/class.template.php" );

    $meineKlasse  = new  tpl ();  // Klasse wird Initialisiert in $meineKlasse. Wird benötigt um die Klasse bekannt zu machen und um mit der angegebenen Variable die Methoden auf zu rufen.

    // Methoden ruft man fast genau wie innerhalb von Klassen auf...
    $HierSpeicherIchMeinenInhalt  $meineKlasse -> loadContent ( "index.htm" );  // Mit dem unterschied, das man hier nicht $this-> schreiben kann, da es außerhalb der Klasse ist.


    $HierSpeicherIchMeinenInhalt  str_replace ( "{weissdergeier}" "Mein neuer Inhalt" $HierSpeicherIchMeinenInhalt );

    // Nun zur Ausgabe
    $meineKlasse -> Ausgeben ( $HierSpeicherIchMeinenInhalt );
    ?>
    index.htm
    PHP:
    <! DOCTYPE html  PUBLIC  "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" >
    <
    html xmlns = "http://www.w3.org/1999/xhtml" >
    <
    head >
    <
    meta http - equiv = "Content-Type"  content = "text/html; charset=utf-8"  />
    <
    title >{ seitentitel }</ title >
    </
    head >

    <
    body >
    {
    weissdergeier }
    </
    body >
    </
    html >
    2. Schlusswort
    Puh... ich saß jetzt locker 2 Stunden an dem ganzen hier. Ich hoffe es ist nicht zu komplex erklärt... OOP ist in der grundlage auch recht simpel.. und eigentlich habe ich nur einen Bruchteil angeschnitten. Es gibt ganze Bücher darüber! Ich empfehle mal in google nach PHP OOP zu suchen und weiter zu studieren und zu üben natürlich.

    Ich habe stark in der konzentration gegen ende nachgelassen, noch einmal die bitte: Bei Vorschlägen, Kritik oder Fragen schreibt mir eine PM

    2.1 Geistiges Eigentum
    Erstellt: 08.08.2008
    Autor: Kai R.
    E-Mail: flyde@gmx.de
    Beschreibung: Ein Tutorial über OOP in PHP4 sowie einer Beispielklasse und Theoretischem Hintergrund. Bei Fragen oder Anregungen sowie Kritik an meine E-Mail schreiben.

    Ich weise darauf hin, dass das komplette Tutorial von mir ist und nicht kopiert wurde.
    Außerdem darf der Inhalt kopiert werden soweit eine Quelle angegeben wurde. Ich stelle diesen Text zur freien Verfügung.


    ---------

    So... das wars dann
    Cya
     
  2. 25. August 2008
    AW: OOP mit PHP4 (Grundlagen + Meine erste Klasse + Theorie OOP sowie Trennung Code-HTML)

    cooles timing, php4 wird von der php-community seit 7. august 2008 nicht mehr weiterentwickelt und is für oop ned wirklich geeignet^^

    für richtiges oop einfach hier vorbeischaun: Objektorientierte Programmierung mit PHP5

    //btw: variablen in klassen nennt man properties (=eigenschaften)
     
  3. 26. August 2008
    AW: OOP mit PHP4 (Grundlagen + Meine erste Klasse + Theorie OOP sowie Trennung Code-HTML)

    Deswegen nun weniger verwertbar und wurde in Showcase geschoben?
    Unter umständen hätte man mir auch netterweise eine PM schreiben können, hätte mir sogar die mühe gemacht es einfach um zu schreiben ...

    Whatever, umsonst die Mühe :]

    cu
     
  4. 18. September 2008
    AW: OOP mit PHP4 (Grundlagen + Meine erste Klasse + Theorie OOP sowie Trennung Code-HTML)

    ...bin grade zufällig auf den thread hier gestoßen und hab mir mal dem link von murdoc angeschaut. Am anfang dachte ich mir, sieht eigentlich ganz gut aus, bis ich dann auf das kapitel vererbung gestoßen bin, dort wurden oop-"designtechnisch" einige gröbere fehler gemacht.

    Hier ein beispiel:

    ...schwachsinn, da vererbung vereinfacht ausgedrückt nur dann sinn macht, wenn die "ist ein" relation gültig ist => class Audi extends Auto (ein audi ist ein auto)

    Im fall vom restaurantkritiker und dem telefon, sollte man immer mit der "hat ein" relation arbeiten!!

    Sprich die klasse Restaurantkritiker müsste dann so aussehen:

    class Restaurantkritiker
    {
    private $geschmack = true;
    private $telefon = new Telefon();

    public function essen_testen ($essen)
    {
    ...
    }
    public function essen_bewerten ($bewertung)
    {
    ...
    }
    }
     
  5. Video Script

    Videos zum Themenbereich

    * gefundene Videos auf YouTube, anhand der Überschrift.