Objektorientiertes Programmieren

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

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

Ratings


Hallo,

also von mir kannst du da nur harte Kritik erwarten.

Mit keinem Wort erklärst du da wirklich verständlich was OOP ist.

Dein PHP Code beruht auf dem Steinzeitalter von PHP 4. Die ganzen globalen Variablen haben null und nüscht mit OOP zu tun, da wendest du genau das an was mit OOP eigentlich richtig gut via DI oder DIC zu umgehen ist, notfalls auch mit dem Registry Pattern.

Außerdem hast du dir ein ganz schlechtes Beispiel ausgesucht um OOP zu erklären, du verstößt in deinem TUT und Beispiel so ziemlich gegen alle Vorzüge und Regeln von OOP.

Bitte nimm das ganz schnell wieder raus, damit tust du niemanden ein Gefallen, ganz im Gegenteil, die die das lesen bekommen ein völlig falsches Bild von OOP.

Ich konnte nicht ein Wort lesen warum OOP gegenüber der Prozeduralen Programmierung Vorteile hat, leider konnte ich auch kein einziges Wort über die Nachteile der OOP lesen.

Ich schätze, beziehungsweise unterstelle dir an der Stelle mal, dass du selber noch nicht mal richtig verstanden hast was OOP ist und welche Möglichkeiten es damit gibt. Vieleicht setzt du dich auch selber noch mal auf den Hosenboden und lernst und fängst dann noch mal an ein TUT zu schreiben.
Dann wünsche ich mir das du auf das Kapitel Interfaces, Abstrakte Klassen, Vererbung, DI (zum vermeiden direkter Abhängigkeiten), kapseln von Daten und Funktionalitäten eingehst.

Wenn du genau diese Sachen ordentlich und vernünftig rüber bringen kannst, dann wirst du auch von mir positive Zeilen lesen können.

Gruß der_litter, im Forum litterauspirna
Written by der_litter At 08.05.2012 20:56:11

gab es vor 8 jahren schon PHP? (ich weiß es wirklich nicht)
Written by phpsven At 15.02.2011 17:37:43

Irgendwie kommt mir das Tutorial bekannt vor. Hab ich wahrscheinlich vor 8 Jahren schon mal gesehen (oder geschrieben :-P)...
Written by jschultz At 14.02.2011 00:37:24

die SQL-Anweisung selbst wird mit

[code]
return mysql_query($befehl);
[/code]

ausgeführt. Als Returnwert erhält man die Resourcen-ID
Written by phpsven At 03.01.2011 19:20:47

Ich bin glaube ich zu doof die Sache zu verstehen! Ab Zeile 57 setzt es bei mir aus! Wo und vor allem wie wird die SQL-Abfrage gestartet? Bei Variablen wie $Befehl, $id (den ich sonst nirgendwo finde) denke ich das es einfach 'Platzhalter sind! Gehe ich in der Annahme richtig?

Wenn nein, bitte kurze Aufklärung.
Written by marguenther At 02.01.2011 23:08:46

Here you can write a comment


Please enter at least 10 characters.
Loading... Please wait.
* Pflichtangabe

Related topics

Programmierung - SQL

Dieser SQL-Kurs wendet sich vor allem an Programmierer, die mit Hilfe von SQL auf Datebaken zugreifen, und an alle, die Datenbanken neu entwerfen, erweitern oder abändern wollen ...

webmaster205@

Autor : webmaster205@
Category: mySQL-Tutorials

plotting masters - a professional guide - Teil I

Grafische Interpolation und Bestapproximation von numerischen Wertepaaren: Wir wollen Punkte auf einer Zeichenebene über verschiedene Verfahren miteinander verbinden. ...

EVAMasters

Autor : EVAMasters
Category: PHP-Tutorials

Unkaputtbare Hyperlinks

Wer das Publizieren im Internet nicht bloß als technische Spielerei oder gar eine Designtätigkeit auffasst, wird automatisch ein digitaler Bibliothekar ...

chris@

Autor : chris@
Category: PHP-Tutorials

Anzeige des letzten Besuchers auf der Website

PHP und MySQL ermöglichen es, mit wenig Aufwand Datum und Uhrzeit des letzten Besuchers auf der Homepage anzeigen zu lassen. ...

Lukas Beck

Autor : Lukas Beck
Category: PHP-Tutorials

Konfiguration eines Linux-Rechners als DSL-Router

Dieser Artikel beschreibt wie man unter LINUX einen DSL-Rooter für Windows konfiguriert. ...

tschiesser@

Autor : tschiesser@
Category: Linux & Server Tutorials

Login Skript mit OOP, Sessions und einer MySql Datenbank (Teil 1)

Realisierung eines Login Skriptes mit einer MySql Datenbank, Sessions und PHP mit Objekt orientierter Programmierung. ...

Samir

Autor : Samir
Category: PHP-Tutorials

Webserver, Sicherheit ist realisierbar

Diese Facharbeit beschäftigt sich mit dem Herzstück eines Netzwerkes, dem Webserver. ...

me1@

Autor : me1@
Category: Linux & Server Tutorials

Eigene Web Services mit PHP5 bereitstellen? Kein Problem!

PHP5 bietet das nötige Rüstzeug, um bequem und schnell den eigenen Web Service auf die Beine zu stellen. ...

beebob

Autor : beebob
Category: PHP-Tutorials

Publish a tutorial

Share your knowledge with other developers worldwide

Share your knowledge with other developers worldwide

You are a professional in your field and want to share your knowledge, then sign up now and share it with our PHP community

learn more

Publish a tutorial