Tutorials

Klassen Tutorial

Einloggen
Benutzername:
Passwort:

Passwort vergessen?
Kostenlos
Anmelden
anzeigen
Klassen


1711 - Sniper - 07.04.2006 07:12 Uhr - Version: 1 - - verlinken als BB-Code


Dieses kleine Tutorial erklärt kurz, wieso man Klassen verwenden sollte, und wie diese aufgebaut sind.

Definition und Verwendung von Klasse

Klassen sind wie Kontainer aus denen man Werkzeuge (Die einzelnen Funktionen) nimmt. Natürlich können auch Variablen in den Klassen definiert werden

Hier ein Beispiel ohne Klassen:

1
2
3
4
5
function die_funktion($wert){
    $wert = $wert +1;
}

echo die_funktion("15");


So würde jeder normalerweise eine Funktione schreiben und aufrufen.
Das ist schön und gut. Aber wir wollen vermeiden, dass wir diese Funktion immer wieder in eine Datei schreiben müssen, um sie aufzurufen. (z.B. bei mehreren PHP Dateien).

Mann könnte diese Funktion zwar in eine Externe Datei schreiben, und diese dann immer per include() einbinden, aber sobald eine Funktion aus versehen zweimal eingebunden wird, kommt es zu Fehlern, und ist meist die unschönere Methode. Außerdem bleibt so die Übersicht beim Programmieren erhalten. Um das doppelte Einbinden zu verhindern kann man aber auch require_once oder include_once verwenden. Trotzdem sind Klassen dem vorzuziehen.

Besser sind Klassen, die ein geschlossenes System darstellen.

Nehmen wir eine Datei. Sie heißt "die_klasse.php"

1
2
3
4
5
6
7
8
9
10
11
class die_klasse{
    
    //Hier werden globale Klassenvariablen definiert!
    var $addieren = 1;
    
    function die_funktion($wert){
        //Anstatt jetzt wie oben +1 zu rechnen wird "$addieren" aus der Klasse addiert
        //, die den Wert 1 hat, was denselben Effekt hat.
        $wert = $wert +$this->addieren;
    }
}


Nun geben wir die Klasse einem Objeckt über, um die in Ihr enthaltenen Funktionen aufzurufen

1
2
3
4
5
6
7
8
9
10
11
//jetzt müssen wir die Klasse öffnen, um aus ihr eine Funktion zu extrahieren. Das geht so...

//Die Datei mit der Klasse wird eingebettet
include("die_klasse.php");

//Die Klasse wird an das Objeckt übergeben
$class = &new die_klasse;

//jetzt rufen wir eine Funktion aus der Klasse auf...

echo $class->die_funktion("15");


Zur Klasse ist zu sagen:

Um in einer Funktion einer Klasse eine andere Funktion dieser Klasse aufzurufen benutzt man den parameter $this

Das geht so.

1
2
3
4
5
6
7
8
9
10
11
12
class die_klasse{
    
    function die_erste_funktion(){
        return 5;
    }
    
    function die_zweite_funktion(){
    
    $ergebnis = 5 + $this->die_erste_funktion(); //ergibt 10
        return $ergebnis;
    }
}


Man kann mit $this auch Werte aus VARs der Klasse auslesen und setzen:

1
2
3
4
5
6
7
8
9
10
11
class die_klasse{
    var $wert1 = 7;
    var $wert2 = 4;
    var $wert3;
    
    function rechnen(){
        $ergebnis = $this->wert1 + $this->wert2 //ergibt 11
        $this->wert3 = 5; //Setzt der Klassenvariablen $wert3 den Wert 5
        return $ergebnis;
    }
}


Im Grunde genommen ändert sich nicht viel beim Programmieren, außer das es so übersichtlicher wird.
Es wäre nämlich schwierig aus 100 Dateien 100 mal ein und dieselbe Klasse wegen eines Bugs zu fixen, anstatt dies einmal in einer Zentralen Klasse zu tun.

Ich persönlich empfehle den Einsatz von Klassen, sobald die in ihr gespeicherten Funktionen mehrfach verwendet werden.

Vererbung von Klasse

Man kann mit Klassen auch Klassenfunktionen und Variablen auf andere Klassen vererben.
Hier gehen wir wie folgt vor…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class A{
    function in_a(){
        echo „Ich bin in A“;
    }
}

//Hier kommt der Teil zum vererben. 
//Dabei werden die Funktionen und Variablen aus A (Parent) auf die neune Klasse (child) vererbt.

class B extends A{
    function in_b(){
        echo „Ich bin in B“;
    }
    
    function test(){
        parent::in_a();
    }
    
    function test2(){
        A::in_a();
    }
}

$klasseA = &new A;
$klasseB = &new B;


Hierbei wurden zwei Klassen erstellt. Die erste (A) enthält die Funktion „in_a()“ und die zweite Klasse (B) enthält drei Funktionen.
# in_b()
# test()
# test2()

Das Objekt $klasseA enthält nur die Funktion in_a(), das Objekt $klasseB aber die schon oben in der Liste aufgeführten Funktionen UND die Funktionen von A!

$klasseA->in_a(); würde also „Ich bin in A“ wiedergeben, $klasseB->in_a(); aber auch, da diese Funktion von A (Parent) an B (Child) vererbt wurde.

Das wichtige beim Programmieren in der Klasse ist nun die Art und Weise vererbte Funktionen innerhalb der Klasse aufzurufen. Hat man zuvor $this-> genommen, um in einer Klasse eine Funktion aufzurufen, so muss man um eine Vererbte Funktion aufzurufen :: verwenden.
Dies Funktioniert nach folgendem Prinzip.
parent::in_a();
Ruft „in_a()“ aus der Parent Klasse (im oberen Beispiel Klasse A) auf. „parent::“ kann dabei immer verwendet werden, wenn man eine Funktion aus einer „parent“ Klasse in einer Child Klasse aufgerufen werden soll.
Dies Funktioniert auch, wenn man den Klassennamen vor :: verwendet:
A::in_a();

Diese Beispiele wurden in den Funktionene test() und test2() in der Klasse B (oben) demonstriert.

Anmerkung: Hat man eine Klasse, die bereits eine Childklasse ist noch einmal vererbt, so sollte man anstatt parent::eine_funktion() lieber nach folgendem Prinzip vorgehen:
KlassenName1::die_funktion(); und KlassenName2::die_funktion();
Dies sorgt dafür, dass es zu keine Kollisionen kommt, wenn in beiden Childklassen Funktionen mit dem selben Namen vorhanden sind.

MfG,
Sniper

Mitglieder-Kommentare


Es sind leider noch keine Einträge vorhanden!

Nur registrierte Mitglieder könnten einen Kommentar schreiben.

Melde dich doch ganz einfach an, es ist kostenlos. :-)