Eine entsprechende Klasse, die intern PDO nutzt, könnte etwa so aufgebaut sein:
Zentral eine Instanz des Adapters generieren und diese an alle Klasseninstanzen übergeben, die auf die Datenbank zugreifen möchten (Dependency Injection).
Ja, die Erklärung ist ganz gut. Das hier ist vielleicht etwas zu simpel, aber hey, jetzt habe ich es halt getippt:
Noch ein Beispiel für einen wesentlichen grundlegenden Aspekt von Objektorientierung:
Es soll eine Person im Programm abgebildet werden. Eine Person hat meinetwegen als relevante Eigenschaften einen Vornamen, einen Nachnamen und ein Alter.
Der simpelste Ansatz wäre:
PHP:
$vorname = 'Mark';
$nachmane = 'van Bommel';
$alter = 34;
Der stößt allerdings schon an seine Grenzen, wenn mehrere Personen gleichzeitig gespeichert werden sollen. Besser:
PHP:
$person1_vorname = 'Mark';
$person1_nachmane = 'van Bommel';
$person1_alter = 34;
$person2_vorname = 'Lucas';
$person2_nachmane = 'Barrios';
$person2_alter = 26;
Immer noch nicht so richtig komfortabel. Angenommen, die Daten einer Person sollten in eine Textdatei abgespeichert werden. Dazu könnte die folgende Funktion dienen:
PHP:
function person_speichern($vorname, $nachname, $alter)
{
// ...
}
Das wäre sehr umständlich aufzurufen und sobald der Person ein neues Feld (meinetwegen die Adresse) hinzugefügt werden sollte, müssten die Funktionssignatur und sämtliche Aufrufe verändert werden.
PHP:
function person_speichern($vorname, $nachname, $alter, $adresse) { ... }
person_speichern($person1_vorname, $person1_nachname, $person1_alter, $person1_adresse);
Es wäre also praktisch, die Daten einer Person in einer Variable zusammenzufassen und nur noch diese zu übergeben.
PHP:
$person1 = array(
'vorname' => 'Mark',
'nachname' => 'van Bommel',
'alter' => 34,
// ...
);
function person_speichern($person) { ... }
Jetzt ist nur noch blöd, dass das Array auch solche Werte enthalten könnte:
PHP:
$person1 = array(
// Vorname fehlt
'nachname' => null,
'alter' => -392,
// ...
);
Wäre gut, dem Array sagen zu können, dass gewisse Werte oder Kombinationen von Werten keinen Sinn ergeben. Es wäre gut, sicherstellen zu können, dass eine Art „interner Zustand“ der Person immer gültig ist. Das ist beispielsweise mit Objekten mit Gettern/Settern möglich:
PHP:
class Person
{
protected $vorname;
protected $nachname;
protected $alter;
public function __construct($vorname, $nachname, $alter)
{
$this->setVorname($vorname);
$this->setNachname($nachname);
$this->setAlter($alter);
}
public function getVorname()
{
return $this->vorname;
}
public function setVorname($vorname)
{
if (!is_string($vorname) || trim($vorname) === '') {
throw new Exception('Vorname muss ein String und nicht leer sein');
}
$this->vorname = $vorname;
}
public function getNachname()
{
return $this->nachname;
}
public function setNachname($nachname)
{
if (!is_string($nachname) || trim($nachname) === '') {
throw new Exception('Nachname muss ein String und nicht leer sein');
}
$this->nachname = $nachname;
}
public function getAlter()
{
return $this->alter;
}
public function setAlter($alter)
{
if (!is_int($alter) || $alter < 0) {
throw new Exception('Alter muss eine Ganzzahl >= 0 sein');
}
$this->alter = $alter;
}
}
Diese Person beschwert sich über etwaige unsinnige Eingaben und sorgt so dafür, dass ihr Zustand immer – nach gewissen Maßstäben – korrekt ist:
PHP:
$lucas = new Person('Lucas', 'Barrios', -238);
// Fatal error: Uncaught exception 'Exception'
// with message 'Alter muss eine Ganzzahl >= 0 sein'
Verarbeitender Code – etwa die Speicherfunktion – kann so davon ausgehen, korrekte Daten übergeben zu bekommen.
