Warning: file_put_contents(/home/www/web1/html/php_dev/test.txt) [function.file-put-contents]: failed to open stream: Permission denied in /home/www/web1/html/php_dev/sys/lib.activity.php on line 58
Objektorientiertes Programmieren PHP Tutorials nicht nur für Anfänger php-resource.de
php-resource.de

PHP Tutorial: Objektorientiertes Programmieren

Dieses Tutorial beschreibt sehr gut die Wirkunsweise von objektorientiertes Programmieren. Also bestens geeignet um das objektorientierte Programmieren zu verstehen.

|07.12.2010 | phpsven | 36236 | KAT : PHP | | Kommentare 9


1

1
Bei diesem Tutorial geht es darum die Wirkungsweise von OOP (objetktorientiertes Programmieren) verständlich zu machen. Angenommen unser Problem besteht innerhalb eines Projektes darin mehrere Datenbanken ansprechen zu müssen. Da läßt sich per OOP eine leichte Lösung finden. Wir schreiben dafür eine Klassendatei mit dem Namen class_datenbank.php.

als erstes die Klasse an sich

in der Variablen $dbname wird der Datenbankname, der beim Erzeugen der Instanz übergeben wird, gespeichert. Außerdem setzen wir gleich noch den Datenbankhost, Datenbankbenutzername und Datenbankpasswort. (hier bitte die richtigen Werte einsetzen, sonst gibts ne Fehlermeldung)


 1 
 2 <?php
 3 
class datenbank {
 4 
 5  
// Datenbankhost
 6  
var $host 'localhost';
 7 
 8  
// Datenbankbenutzername
 9  
var $user 'admin';
10 
11  
// Datenbankpasswort
12  
var $passwort 'projekt';
13 
14  
// Datenbankname speichern
15  
var $dbname '';
16 
17  function 
datenbank$name) {
18   
// diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
19   // Datenbankname in $dbname speichern
20   
$this->dbname $name;
21  }
22 }
23 
?>
24 



dann als nächstes wird beim Initialisieren der Klasse überprüft, ob wir schon eine Verbindung zum Datenbankserver haben, wenn nicht wird eine hergestellt. Dafür verwenden wir eine Variable außerhalb der Klasse $verbindung, diese muß jedoch innerhalb der Funktionen mit -global- eingebunden werden, wird also für die Funktion innerhalb einer Klasse sichtbar und kann verwendet und verändert werden. neu hinzu gekommenes steht in gestrichelten Linien


 1 
 2 <?php
 3 
// -----------------------
 4 // hier die Variable in der wir speichern ob wir schon eine 
 5 // Datenbankverbindung haben, gleichzeitig nutzen wir diese als 
 6 // Verbindungskennung um unsere Datenbanken anzusprechen
 7 
$verbindung NULL;
 8 
// -----------------------
 9 
10 
class datenbank {
11 
12  
// Datenbankhost
13  
var $host 'localhost';
14 
15  
// Datenbankbenutzername
16  
var $user 'admin';
17 
18  
// Datenbankpasswort
19  
var $passwort 'projekt';
20 
21  
// Datenbankname speichern
22  
var $dbname '';
23 
24  function 
datenbank$name) {
25   
// diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
26 
27   // ------------------------
28   // Variable $verbindung mit global einbinden
29   
global $verbindung;
30   
// ------------------------
31 
32   // Datenbankname in $dbname speichern
33   
$this->dbname $name;
34  
35  
// ------------------------
36  // abfragen ob Verbindung zum Server bereits besteht, wenn nicht
37 // Verbindung herstellen
38  
if(!$verbindung$verbindung = @mysql_connect$this->host$this->user$this->passwort);
39  
40  
// haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
41  
if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
42  
// ------------------------
43  
}
44 }
45 
?>
46 



Jetzt noch die Funktion die eine Verbindung zu der Datenbank selber herstellt. Der Grund warum wir diese Funktion extra aufrufen werden wir weiter unten lesen. Vor dem Verbinden überprüfen wir noch welche Datenbank grade aktiv ist, wenn die schon aktiv ist die wir wollen, brauchen wir die Datenbank nicht mehr verbinden (spart Rechenzeit), dazu definieren wir noch eine Variable, die außerhalb der Klasse liegt.


 1 
 2 <?php
 3 
// hier die Variable in der wir speichern ob wir schon eine 
 4 // Datenbankverbindung haben, gleichzeitig nutzen wir diese als 
 5 // Verbindungskennung um unsere Datenbanken anzusprechen
 6 
$verbindung NULL;
 7 
 8 
// --------------------------
 9 
$dbaktiv '';
10 
// --------------------------
11 
12 
class datenbank {
13 
14  
// Datenbankhost
15  
var $host 'localhost';
16 
17  
// Datenbankbenutzername
18  
var $user 'admin';
19 
20  
// Datenbankpasswort
21  
var $passwort 'projekt';
22 
23  
// Datenbankname speichern
24  
var $dbname '';
25 
26  function 
datenbank$name) {
27   
// diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
28 
29   // Variable $isverbindung mit global einbinden
30   
global $verbindung;
31 
32   
// Datenbankname in $dbname speichern
33   
$this->dbname $name;
34  
35   
// abfragen ob Verbindung zum Server bereits besteht, wenn nicht Verbindung herstellen
36   
if(!$verbindung$verbindung = @mysql_connect$this->host$this->user$this->passwort);
37  
38   
// haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
39   
if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
40 
41  }
42 
43 
// -----------------------------
44 // hier die Funktion die eine Verbindung zu einer Datenbank herstellt
45  
function connect_db$name) {
46 
47   
// Variable $verbindung und $dbaktiv einbinden
48   
global $verbindung$dbaktiv;
49 
50   
// Datenbank $name Verbindung herstellen
51   
$result = @mysql_select_db$name$verbindung);
52 
53   
// haben wir Datenbankverbindung? wenn nein Fehlermeldung
54   
if(!$result) die("Datenbank ".$name." nicht vorhanden.");
55 
56   
// Datenbankverbindung besteht, aktuellen Datenbanknamen in $dbaktiv speichern
57   
else $dbaktiv $name;
58  }
59 
// -----------------------------
60 
}
61 
?>
62 



Dann brauchen wir noch eine Funktion, die die SQL-Abfragen selbst bearbeitet. Das besondere ist aber, daß diese Funktion zuerst abfragt, mit welcher Datenbank wir verbunden sind, es wird also die aktuelle mit der verglichen, die wir ansprechen wollen. Ist nicht die aktiv die wir haben wollen (wir haben ja den Datenbank-Namen mit Instanzieren der Klasse in $dbname gespeichert) rufen wir die Funktion connect_db() auf.


 1 
 2 <?php
 3 
// hier die Variable in der wir speichern ob wir schon eine 
 4 // Datenbankverbindung haben, gleichzeitig nutzen wir diese als 
 5 // Verbindungskennung um unsere Datenbanken anzusprechen
 6 
$verbindung NULL;
 7 
$dbaktiv '';
 8 
 9 class 
datenbank {
10 
11  
// Datenbankhost
12  
var $host 'localhost';
13 
14  
// Datenbankbenutzername
15  
var $user 'admin';
16 
17  
// Datenbankpasswort
18  
var $passwort 'projekt';
19 
20  
// Datenbankname speichern
21  
var $dbname '';
22 
23  function 
datenbank$name) {
24   
// diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
25 
26   // Variable $verbindung mit global einbinden
27  
global $verbindung;
28 
29   
// Datenbankname in $dbname speichern
30   
$this->dbname $name;
31  
32   
// abfragen ob Verbindung zum Server bereits besteht, wenn nicht Verbindung herstellen
33   
if(!$verbindung$verbindung = @mysql_connect$this->host$this->user$this->passwort);
34  
35   
// haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
36   
if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
37 
38  }
39 
40  
// hier die Funktion die eine Verbindung zu einer Datenbank herstellt
41  
function connect_db$name) {
42   
// Variable $verbindung und $dbaktiv einbinden
43   
global $verbindung$dbaktiv;
44 
45   
// Datenbank $name Verbindung herstellen
46   
$result = @mysql_select_db$name$verbindung);
47 
48   
// haben wir Datenbankverbindung? wenn nein Fehlermeldung
49   
if(!$result) die("Datenbank ".$name." nicht vorhanden.");
50 
51   
// Datenbankverbindung besteht, aktuellen Datenbanknamen speichern
52   
else $dbaktiv $name;
53  }
54 
55  
// ---------------------------
56  // hier die Funktion die die SQL-Abfragen bearbeitet
57  
function abfrage$befehl) {
58 
59   
// wieder per global $dbaktiv einbinden
60   
global $dbaktiv;
61 
62   
// ist der in $dbname gespeicherte Datenbankname nicht der aktuelle? dannFunktion connect_db() aurufen
63   
if($this->dbname!=$dbaktiv$this->connect_db$this->dbname);
64 
65   
// Aufruf der PHP-Funktion mysql_query() um den SQL Befehl abzuarbeiten und die Resourcen-Kennung zurück geben
66 
67   
return mysql_query$befehl);
68  }
69 
// ---------------------------
70 
}
71 
?>
72 



Um die Daten aus einer Datenbankanfrage auch wirklich verwenden zu können brauchen wir noch eine Funktion die unsere Resourcen-Kennung in ein "Daten-Array" umwandelt.


 1 
 2 <?php
 3 
// hier die Variable in der wir speichern ob wir schon eine 
 4 // Datenbankserververbindung haben, gleichzeitig nutzen wir diese als 
 5 // Verbindungskennung um unsere Datenbanken anzusprechen
 6 
$verbindung NULL;
 7 
$dbaktiv '';
 8 
 9 class 
datenbank {
10 
11  
// Datenbankhost
12  
var $host 'localhost';
13 
14  
// Datenbankbenutzername
15  
var $user 'admin';
16 
17  
// Datenbankpasswort
18  
var $passwort 'projekt';
19 
20  
// Datenbankname speichern
21  
var $dbname '';
22 
23  function 
datenbank$name) {
24   
// diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
25 
26   // Variable $verbindung mit global einbinden
27   
global $verbindung;
28 
29   
// Datenbankname in $dbname speichern
30   
$this->dbname $name;
31  
32   
// abfragen ob Verbindung zum Server bereits besteht, wenn nicht 
33 // Verbindung herstellen
34   
if(!$verbindung$verbindung = @mysql_connect$this->host$this->user$this->passwort);
35  
36   
// haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
37   
if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
38 
39  }
40 
41  
// hier die Funktion die eine Verbindung zu einer Datenbank herstellt
42  
function connect_db$name) {
43   
// Variable $verbindung und $dbaktiv einbinden
44   
global $verbindung$dbaktiv;
45 
46   
// Datenbank $name Verbindung herstellen
47   
$result = @mysql_select_db$name$verbindung);
48 
49   
// haben wir Datenbankverbindung? wenn nein Fehlermeldung
50   
if(!$result) die("Datenbank ".$name." nicht vorhanden.");
51 
52   
// Datenbankverbindung besteht, aktuellen Datenbanknamen speichern
53   
else $dbaktiv $name;
54  }
55 
56  
// ---------------------------
57  // hier die Funktion die die SQL-Abfragen bearbeitet
58  
function abfrage$befehl) {
59 
60   
// wieder per global $dbaktiv einbinden
61   
global $dbaktiv;
62 
63   
// ist der in $dbname gespeicherte Datenbankname nicht der aktuelle? dannFunktion connect_db() aurufen
64   
if($this->dbname!=$dbaktiv$this->connect_db$this->dbname);
65 
66   
// Aufruf der PHP-Funktion mysql_query() um den SQL Befehl abzuarbeiten und die Resourcen-Kennung zurück geben
67 
68   
return mysql_query$befehl);
69  }
70  
// --------------------------
71 // hier unsere Funktion mit der wir unsere Daten aus einer 
72 // Datenbankanfrage zurück geliefert bekommen( hat eigentlich mit der 
73 // Funktionsweise in diesem Tutorial nichts zu tun, diese Funktion 
74 // könnte genauso gut auch außerhalb der Klasse definiert sein)
75 
76  
function lade_satz$id) {
77   return 
mysql_fetch_array($id);
78  }
79  
// --------------------------
80 
}
81 
?>
82 



Jetzt haben wir es fast geschafft. Und jetzt werden wir auch erfahren, warum mit diesem Tutorial eigentlich jeder die Wirkungsweise und Vorteile von OOP verstehen sollte.

Wir müssen die Klassendatei in einer normalen PHP-Datei einbinden (require) und die Datenbank-Instanzen erzeugen. Wir nehmen mal an wir haben 3 verschiedene Datenbanken (user, admin, nachrichten) und wollen im Programm selber ohne viel Auwand zwischen diesen Datenbanken hin und her springen.


 1 
 2 <?php
 3 
// Klasse einbinden
 4 
require("class_datenbank.php");
 5 
 6 
// Instanzen erzeugen
 7 
$user = new datenbank("user");
 8 
$admin = new datenbank("admin");
 9 
$nachrichten = new datenbank("nachrichten");
10 
11 
// um jetzt eine Datenbank anzusprechen brauchen wir diese nur mit 
12 // dem "Zeiger" ( der den gleichen Namen hat wie die Datenbank aus 
13 // der wir die Daten haben wollen) ansprechen und uns um nichts weiteres zu kümmern
14 
15 // SQL-Anweisung in Datenbank admin ausführen
16 
$result $admin->abfrage("SELECT * FROM admin WHERE <bedingungen>");
17 
18 
// Daten holen
19 
while($row=$db->lade_satz($result)) {
20  << 
weitere Anweisungen >>
21 }
22 
23 
// SQL Anweisung in $atenbank nachrichten ausführen
24 
$nachrichten->abfrage("INSERT INTO nachrichten  << Anweisungen >>");
25 
26 
?>
27 



wenn Sie also Daten aus der Datenbank user haben wollen müssen Sie die Abfrage mit dem zeiger $user durchführen

für die Datenbank admin mit dem Zeiger $admin

für die Datenbank nachrichten mit dem Zeiger $nachrichten

Aber wie funktioniert das?
da wir bei jeder Instanzierung ($admin = new datenbank("admin")) einen anderen Datenbanknamen (in der Variable $dbname) angegeben haben, merken diese 3 Instanzen die ihnen zugewiesenen Datenbanknamen, aus Sicht der Instanz $user heißt die Datenbank user ( gespeichert in $dbname), aus Sicht der Instanz $admin gibt es nur die Datenbank admin und aus Sicht der Instanz $nachrichten nur die Datenbank nachrichten. man könnte auch sagen, die Datenbanknamen sind aus Sicht der Instanzen relativ. oder noch anders, aus Sicht der Instanz $user hat $dbname einen anderen Inhalt als aus der Sicht der Instanz $admin oder $nachrichten.

Viel Spaß mit diesem Tutorial, der wie ich glaube die Wirkungsweise von OOP sehr gut erklärt.

ich bitte um Feedback
Kommentare zum Tutorial
Tutorial kommentieren
 
08.05.2012 20:56:11 Hallo, also von mir kannst du da nur harte Kritik erwarten. Mit keinem Wort erklärst du d ...
15.02.2011 17:37:43 gab es vor 8 jahren schon PHP? (ich weiß es wirklich nicht) ...
14.02.2011 00:37:24 Irgendwie kommt mir das Tutorial bekannt vor. Hab ich wahrscheinlich vor 8 Jahren schon mal gesehen ...
03.01.2011 19:20:47 die SQL-Anweisung selbst wird mit return mysql_query($befehl); aus ...
02.01.2011 23:08:46 Ich bin glaube ich zu doof die Sache zu verstehen! Ab Zeile 57 setzt es bei mir aus! Wo und vor alle ...

Alle Kommentare anzeigen ...
 
Über den Autor
phpsven

phpsven

Status
Premium Mitglied

Beruf
Unbekannt

Mitglied seit:
31.01.2010

letzte Aktivität
08.07.2015

 

Tutorial bewerten

Hat Ihnen dieses Tutorial gefallen? Dann bewerten Sie es jetzt! Fünf Sterne bedeutet "Sehr gut", ein Stern "Unzureichend".



 

aktuelle Artikel

Mit Web-Templates Geld verdienen

Mit Web-Templates Geld verdienenWeb-Templates gewinnen immer mehr an Bedeutung. Erfahre hier, wie du dir mit dem TemplateMonster-Marktplatz neue Verkaufswege erschließen kannst.

17.10.2017 | Neu | Berni

Kostenloser PHP Editor Codelobster

Kostenloser PHP Editor CodelobsterEin einfach zu verwendender PHP, HTML, CSS, JavaScript Editor mit vielen Funktionen

21.09.2017 | Neu | Berni