[PHP] Verstehe Class nicht.

Tab

unlimited
ID: 374854
L
26 Juni 2007
900
71
Hallo ihr Lieben,

nun sitze ich schon 3 Tage nur an dieser OOP class Variante. SO genau weiß ich nicht woran er hapert, ich denke das es zu 80% an dem Sinn von Class geht.

Hier mal eine Probeklasse von mir:

PHP:
<?php

class test {
    public $testname = "Markus";
    public $true = "true";
    
    public function show_name() {
        if ($true = "true"){
            echo "Die if-Abfrage ist mit true richitg!";
        }else {
            echo "Falsch";
        }
    }    
}

$foo = new test;
$foo->show_name();

?>

Ich habe einiges in letzter Zeit ausprobiert. In diesem Beispiel wird natürlich dir richite Antwort angezeigt. Diese Klasse hat auch kein Sinn. Was bringen mir Klasse, und wogenau setzt man sie ein? Lese immer Beispiele vonwegen. ja auot hat türen und davon mehrere und von Autos gibt es verscheidene Typen... ? Da steige ich nicht durch, habt ihr vllt. ein Code nahes Beispeil, welches auch im Inet mal gebracuht wird. Und dazu eine kleine Beschreibung?

Diese Seiten habe ich mir schon reingezogen:

Alles von de.php.net (function, class)
https://www.dynamic-webpages.de/50.tutorials.php?dwp_tutorialID=2
Und einiges aus den Büchern

Ich bitte um Hilfe, liebe Grüße,
Markus
 
Ganz kurz: Zeile 8 is Quark, die is nämlich immer true ;)

Wegen OOP hab ich n Thread hier in Erinnerung. Ich such ihn dir später mal raus.
 
Ja ich, weiß hab ich doch auch geschrieben, halt nur so ein test für mich gewesen ob if fragen da drinne gehen ;)

Danke, dass du mir den Link raussuchst.
 
Vielen dank für deinen schnellen Post:

Hab verstanden worauf du hinaus willst ;).

Nun mal zurück zu den Klassen. Habe mir jetzt mal ein Code aus dem Thread genommen:

PHP:
 <?php

// die Klasse "Auto" definieren
class auto
{

    // eine Eigenschaft/Attribut festlegen
    var $benoetigter_kraftstoff;

    // eine Methode (flapsig Funktion) festlegen
    function tankdeckel_oeffnen()
    {
        // Ihr Auto spricht mit Ihnen - wenn der
        // Tankdeckel geöffnet wird, sagt es, welchen
        // Kraftstoff es benötigt
        echo "<p>Bitte mit $this->benoetigter_kraftstoff betanken";
    }
}

// bisher passiert noch gar nichts,
// jetzt wird aus der Klasse ein Objekt erzeugt
$auto_1 = new auto;

// dem Auto wird nun der Kraftstoff zugewiesen,
// eine Eigenschaft (Attribut) wird definiert
$auto_1->benoetigter_kraftstoff = "Diesel";

// und nun wird das erste mal die Methode (Funktion)
// tankdeckel_oeffnen aufgerufen und das Auto sagt
// freudig, was es für Sprit benötigt
$auto_1->tankdeckel_oeffnen();
?>
Ich versuche den Code jetzt mal mit eigenen Worten zusammenzudenken:

Es wird eine Klasse AUto erstellt. In der Klasse wird eine Variable benötigter_kraftstoff erstellt, welcher aber noch keinen Wert hat. Nun wurde eine Funktion aufgebaut, bei der eine Aussage über den Wert von benötigter_kraftstoff gemacht wird. Nun könnte man den oberen Code in eine andere Dateispeichern und einfach includieren. In der Hauptdatei muss dann nur noch folgender Code folgen: Es wird ein Objekt mit dem Namen Auto_1 erstellt, dem wird jetzt ein Wert für benötigter_kraftstoff zugewiesen und am Ende die Funktion tankdeckel_öffnen ausgeführt.

Habe ich das so richitg verstanden?

Boa, zum SInn nochmal, kannst du theHacker, mal in paar kurzen Sätzen, dein Sinn von Klassen aufführen? Und am besten auch mit einem Beispiel? Also vllt. zu eienr Dtaenbank verb. Oder was es noch so gibt?

Liebe Grüße und vielen Dank,
Markus
 
Habe ich das so richitg verstanden?
Keine Ahnung. Du hast nur den Code vorgelesen. Ob du ihn verstanden hast, weiß ich nicht.
An Gesichts der nachfolgenden Frage nehm ich aber mal nicht an.
Und am besten auch mit einem Beispiel? Also vllt. zu eienr Dtaenbank verb.
Sehr schlechtes Beispiel. Normalerweise hat man immer nur eine Datenbankverbindung, d.h. OOP dort zu erklären, würde mehr Verwirrung stiften.
Boa, zum SInn nochmal, kannst du theHacker, mal in paar kurzen Sätzen, dein Sinn von Klassen aufführen? Und am besten auch mit einem Beispiel?
Eigentlich war der andere Thread schon mit einem Monster-Beispiel von mir versehen, aber das hat dir ja nicht gereicht.

Laut Nickpage bist du erst 15, d.h. ich kann mir das Beispiel mit den komplexen Zahlen wohl sparen :-?

Glücklicherweise haben wir da noch einen anderen mathematischen Vertreter, der wunderbar für OOP geeignet is: der Bruch :)

Begriffe:
Ein Objekt ist "eine komplexe Variable, die evtl. auch was tun kann". Eine Klasse ist der Bauplan für ein Objekt. Das Objekt selber wird in einer Variable abgespeichert.
Das Objekt ist also das Ding, mit dem du arbeitest. Die Klasse ist gar nix. Mit ihr kannst du nichts tun, außer Objekte instanzieren.

Eine integer-Variable ist eine einfache Variable. Du kannst ihr eine ganzzählige Zahl in einem gewissen Bereich zuordnen und mit ihr arbeiten, indem du verschiedene Operatoren anwendest.
PHP:
$int_var = 42;
$squere = $int_var * $int_var;
Du kennst Brüche ?
Der Bruch ist der Grundbauplan für etwas komplexeres als nur n Integer.
Bauen wir eine Klasse.

Was für Eigenschaften hat ein Bruch ?
Richtig, einen Zähler und einen Nenner. Diese beiden Eigenschaften sind seine Variablen.

Was kann man mit einem Bruch machen ?
Man kann ihn kürzen, negieren, addieren, subtrahieren, multiplizieren, dividieren, potenzieren, radizieren, Reziprokwert bilden... Zusätzlich in der Programmierung möchte man ihn darstellen und ausgeben.
All das sind die Methode der Klasse: Alles, was ich mit dem Ding anstellen kann.

Ich arbeite mal kurz und poste dir danach exemplarisch eine PHP-Klasse, die einen Bruch repräsentiert. Danach kannst du mit ihr arbeiten und so das OOP-Konzept verstehen (ich hoffs zumindest ;)).
 
PHP:
<?php

class Bruch
{

  // Zähler des Bruchs
  private $zaehler;
  // Nenner des Bruchs
  private $nenner;
  
  
  
  // Konstruktor, erwartet Zähler und Nenner
  function __construct($p, $q)
  {
    $this->zaehler = $p;
    $this->nenner = $q;
  }
  
  
  // Formatiert einen Bruch als "p/q"
  public function toString() // Namensgebung kommt von Java, nicht wundern ^^
  {
    return $this->zaehler . '/' . $this->nenner;
  }
  
  
  // Formatiert einen Bruch als Dezimalbruch
  public function dezimalbruch()
  {
    return $this->zaehler / $this->nenner;
  }
  
  
  // Erweitert mit einem Faktor
  public function erweitern($fak)
  {
    $this->zaehler *= $fak;
    $this->nenner *= $fak;
  }
  
  
  // Kürzt mit einem Faktor, so dies geht
  public function kuerzen($fak)
  {
    if(($this->zaehler % $fak) || ($this->nenner % $fak))
      throw new Exception("kann " . $this->toString() . " nicht mit $fak kürzen");
      
    $this->zaehler /= $fak;
    $this->nenner /= $fak;
  }
  
  
  // Kürzt vollständig
  public function vollstaendig_kuerzen()
  {
    // mit ggT kürzen
    $fak = Bruch::ggT($this->zaehler, $this->nenner);
    
    if($fak != 1)
      $this->kuerzen($fak);
  }
  
  
  
  
  
  // Addiert zwei Brüche
  public static function add($op1, $op2)
  {
    // Hauptnenner = kgV
    $hauptnenner = Bruch::kgV($op1->nenner, $op2->nenner);
    
    // auf Hauptnenner
    $op1->erweitern($hauptnenner / $op1->nenner);
    $op2->erweitern($hauptnenner / $op2->nenner);
    
    return new Bruch($op1->zaehler + $op2->zaehler, $op1->nenner);
  }
  
  
  // Subtrahiert zwei Brüche
  public static function sub($op1, $op2)
  {
    // Hauptnenner = kgV
    $hauptnenner = Bruch::kgV($op1->nenner, $op2->nenner);
    
    // auf Hauptnenner
    $op1->erweitern($hauptnenner / $op1->nenner);
    $op2->erweitern($hauptnenner / $op2->nenner);
    
    return new Bruch($op1->zaehler - $op2->zaehler, $op1->nenner);
  }
  
  
  // Multipliziert zwei Brüche
  public static function mul($op1, $op2)
  {
    return new Bruch($op1->zaehler*$op2->zaehler, $op1->nenner*$op2->nenner);
  }
  
  
  // Dividiert zwei Brüche
  public static function div($op1, $op2)
  {
    if(!$op2->zaehler)
      throw new Exception("Division durch 0");
      
    return new Bruch($op1->zaehler*$op2->nenner, $op1->nenner*$op2->zaehler);
  }
  
  
  // negiert den Bruch
  public static function negieren($op)
  {
    return new Bruch(-$op->zaehler, $op->nenner);
  }
  
  
  // bildet den Kehrwert
  public static function reziprok($op)
  {
    if(!$op->zaehler)
      throw new Exception("Reziprokwert von 0");
      
    return new Bruch($op->nenner, $op->zaehler);
  }
  
  
  
  
  // ggT: private Methode
  private static function ggT($a, $b)
  {
    // Euklid:
    return ($a % $b) ? Bruch::ggT($b, $a % $b) : $b;
  }
  
  
  // kgV: private Methode
  private static function kgV($a, $b)
  {
    // kgV(a,b) = a*b / ggT(a,b)
    return $a * $b / Bruch::ggT($a, $b);
  }
  
}

?>
So, die Variablengebung is ned sonderlich einheitlich, aber du willst ja was verstehen. Vermutlich is das jetzt auch ned alles perfekt, aber es soll ja nur als Beispiel dienen.

Ein Bruch ist eine Klasse mit zwei Eigenschaften: Zähler und Nenner
Beide Eigenschaften sind privat, d.h.
PHP:
$a = new Bruch(1, 2);
$a->nenner = 8;
führt zum Fehler. Dich geht das nichts an, was im Bruch drin is. Für dich is nur wichtig, dass es funktioniert, nicht wie (Geheimniskrämer-Prinzip).

Der Konstruktor erstellt einen neuen Bruch mit einem Zähler und einem Nenner:
PHP:
$a = new Bruch(1, 4); // "ein Viertel"
Mit toString() kannst du ihn in Bruchschreibweise "p/q" und mit dezimalbruch() als Dezimalbruch ausgeben lassen:
PHP:
$a = new Bruch(1, 4);
echo $a->toString(); // 1/4
echo $a->dezimalbruch(); // 0.25
Weiterhin gibt es drei Methoden, mit denen du den Bruch erweitern, kürzen und automatisch vollständig kürzen lassen kannst:
PHP:
$a = new Bruch(2, 4);
$a->erweitern(3);
echo $a->toString(); // 6/12
$a->kuerzen(3);
echo $a->toString(); // 2/4
$a->vollstaendig_kuerzen();
echo $a->toString(); // 1/2
Die arithmetischen Operatoren sind statisch, d.h. sie sind nicht von Objekten abhändig und dürfen auch nicht in diesem Kontext benutzt werden (wäre ja auch sinnlos).
PHP:
$a = new Bruch(2, 4);
$a->add($a, $a); // FEHLER
Du hast Methoden für Addition, Subtraktion, Multiplikation, Division, Negation und Bildung des Reziprokwerts zur Verfügung:
PHP:
$a = new Bruch(1, 2);
$b = new Bruch(3, 4);
$x = new Bruch(0, 3);

$c = Bruch::add($a, $b); // a+b
echo $c->toString()."\n";
$c = Bruch::sub($a, $b); // a-b
echo $c->toString()."\n";
$c = Bruch::mul($a, $b); // a*b
echo $c->toString()."\n";
$c = Bruch::div($a, $b); // a/b
echo $c->toString()."\n";

$c = Bruch::negieren($a); // -a
echo $c->toString()."\n";
$c = Bruch::reziprok($b); // b^(-1)
echo $c->toString()."\n";

try
{
  $b->kuerzen(2); // 3/4  |:(2/2)
  echo $b->toString()."\n";
}
catch(Exception $e)
{
  echo "Exception: ".$e->getMessage()."\n";
}

try
{
  $c = Bruch::div($a, $x); // a/0
  echo $c->toString()."\n";
}
catch(Exception $e)
{
  echo "Exception: ".$e->getMessage()."\n";
}

try
{
  $c = Bruch::reziprok($x); // 0^(-1)
  echo $c->toString()."\n";
}
catch(Exception $e)
{
  echo "Exception: ".$e->getMessage()."\n";
}
Die unteren beiden Methoden ggT() und kgV() sind privat. Wie Zähler und Nenner kennst du diese beiden Methoden nicht. Du hast keine Ahnung, was sie tun und warum sie da sind. Dir aber wurscht: Hauptsache, die Klasse tun, was sie tun sollen.

Probiere mit dem Code rum und stell dann deine Fragen.

edit:
Das komische "& #37;" is vom Forum, das krieg ich ned weg. Kp.
Das is also auch n Prozentzeichen, sollte klar sein.
 
wirf mal die Forensuche an, ich kann mich da an einen Thread in den letzten 8 Wochen (?) erinnern, der genau das gleiche Thema hatte und der betreffende es verstanden hat (zumindest tat er so^^)
 
Die von Dir oben gepostete Klasse hat in der Tat keinen Sinn. Das ist aber auch nicht der Zweck von Klassen. Es gibt durchaus Bezüge, wo der Einsatz einer Klasse sinnvoll ist.

Ein gutes Beispiel wäre z.B. die Verarbeitung von Formularen. Ich habe mir für mein CMS eine Klasse geschrieben, mit der ich mehrere Formulare auf einer Seite platzieren kann, wobei die Klasse selbständig erkennt, welches Formular vom Benutzer abgeschickt wurde, und gleichzeitig auch überprüft, ob alle nötigen Felder (kann ich beim Definieren einstellen ob ein Feld ausgefüllt werden muß oder nicht) auch ausgefüllt sind, und markiert mir nicht ausgefüllte Felder automatisch in einer anderen Farbe.

Ein anderes Beispiel wäre z.B. das Arbeiten mit Datenbanken. In meinem CMS habe ich eine Klasse, die mehrere Datenbanken verwalten und gleichzeitig ansprechen kann, wobei diese auch auch verschiedenen Servern liegen können. Dadurch kann ich flexibel meine Seite auf mehrere Datenbanken verteilen, und muss mich nicht mit hunderten Tabellen in einer herumquälen.

Die Dritte Klasse im Bunde wäre z.B. meine Template Klasse. Jedes Template ist eine eigene Klasse. Mein CMS bedient sich jedoch nur der "Template" Klasse, die wiederum die Klassen der Templates anspricht, jedoch ohne diese generell zu kennen. So kann ich einen einheitlichen Standard für die Gestaltung von Templates schaffen, ohne dass sich die Templates wegen der Funktionsnamen in die Quere kommen.

Wie Du siehst ist OOP nicht umsonst und für nichts, man muss halt nur wissen wo man es am besten einsetzt.
 
letzter Versuch Class

Hallo ihr Lieben,

ich arbeite gerade an einer Klasse um Datensätze zu lösche und zu erstellen, nun wüprde ich gerne mal wissen, ob die Klasse vom Aufbau und vom Sinn richitg ist:

PHP:
<?php
class datenbank {
    
    Var $zeile;
    Var $tabelle;
    Var $wert;
    
    Var $into;
    Var $db_tabellen;
    Var $post;
    
    function delete() {
        
        
        echo "DELETE FROM ".$this->tabelle."WHERE ".$this->zeile." = ".$this->wert."";
    }
    
    function add() {
        echo "INSERT INTO ".$this->into." (".$this->db_tabellen.") VALUES (".$this->post.")";
    }
    
}

$ausgabe = new datenbank();
$ausgabe->zeile = "Zeile";
$ausgabe->tabelle = "Tabelle";
$ausgabe->wert = "Wert";
$ausgabe->delete();

$ausgabe->into = "into";
$ausgabe->db_tabellen = "db_tabelle";
$ausgabe->post = "Inahalt";
$ausgabe->add();

?>


Da wo echt ausgegeben wird, kommt natürlich dann noch die Funktion mit query hin. Was würdet ihr anders machen?

Liebe Grüße
Markus
 
Okay, Privat verstehe ich, jedoch nicht, warum amn das direkt übergeben soll?

Liebe Grüße
Markus
 
neija speichern tut man werte (wie auch in datenbanken) doch nur wenn man sie öfter braucht, und wenn ich einen mal den delete query durchführe, werde ich doch nicht wieder den gleichen durchführen, sondern einen neuen, von daher würde ich die werte nicht speichern sondern eben der delete()-methode als parameter übergeben
 
Das heißt nich delete und add unterteilen sonder:

PHP:
$sqlab = "DELETE FROM irgendwo WEHRE id = 4";

Das heißt in der Klasse steht dann nur noch:

PHP:
mysql_query($sqlab);

So?

Liebe Grüße
Markus
 
Ja, also in die Funktion delete kommt, dann einfach der Delete Code rein.

Und man selbst muss dnan der Klasse nur noch diesen Staz übergeben?

DELETE person WHERE id = 9

so richitg?
 
so meine ich das:

PHP:
<?php
class Datenbank {

  function delete($tabelle, $zeile, $wert) {
    echo "DELETE FROM ".$tabelle."WHERE ".$zeile." = ".$wert."";
  }

  function add($into, $db_tabellen, $post) {
    echo "INSERT INTO ".$into." (".$db_tabellen.") VALUES (".$post.")";
  }
}

$ausgabe = new datenbank();
$ausgabe->delete("Zeile", "Tabelle", "Wert");
$ausgabe->add("into", "db_tabelle", "Inahalt");

?>

dummerweise ist die OOP wieder hin, weil es genauso gut mit Funktionen ging, simple sinnvolle Klassen zu finden ist eben schwer, natürlich haben wir hier aber noch die Grupppierung der Methoden in die Klasse, was schon einiges Wert ist :!:
 
Ach, so meisnt du das.

Hast recht, könnten genau so gut nur funktionen nehmen.

Frage:

Bei welchem Beispiel würde eine Klasse sinn machen? Damit ich mir das vorstellen kann?

Liebe Grüße
Markus
 
*Sorry wegen dem Doppelpost, aber bin am Verzweifeln*

Hier die Datei mit der Klasse:

PHP:
<?php
class datenbank{
    
    Var $select;
    Var $from;
    Var $coddi;
    Var $schleife_if_select;
    Var $schleife_else_select;
    
    function select () {
        $sql = "SELECT ".$this->select." FROM ".$this->from." ORDER by id Desc";
        $result = mysql_query($sql);
        
        if (!$result) {
              echo "Es ist ein Fehler aufgetreten.";
            }else {
              while ($row = mysql_fetch_assoc($result)) {
              if ($this->coddi == $row['code']) {
                        
                        echo "$this->schleife_if_select";

                    } else {
                }
                    
            }
    }
}
    
}
?>
Hier wo sie ausgeführt wird:

PHP:
$code_abfrage = new datenbank();
        $code_abfrage->select = "id, code";
        $code_abfrage->from = "coddi";
        $code_abfrage->wincode = $code;
        $code_abfrage->schleife_if_select = "
        if ($code == $row[code]) {
            setcookie('list', 'NONE', mktime()+60*60*24*30);
                $yes = 'true';
        ";
        $code_abfrage->schleife_else_select = "
        setcookie('list', 'NONE', mktime()+60*60*24*30);
                        $ausgabe = 'Ne, leider nicht';
        ";
Hmm, ich denke das es daran liegt, das sich den Variablen schleife_if_select und der anderen zu viel zugewiesen habe. Also einen großen Code?

Bitte helft mir, könnt ihr nen Fehler entdecken?
 
Was ist das Objekt in deiner Klasse um was sich alles dreht? Die Datenbank... und was für Funktionen und Eigenschaften hat so eine Datenbank? Das gehöhrt in die Klasse, mehr nicht. Zb. die Datenbank bildet keine Programmlogik ab also gehört der quatscht mit "$this->schleife_if_select" nicht rein. Ganz primitv würde die Klasse also so aussehen:

PHP:
class Datenbank {
	private $handle;
	
	public function connect() {
		$this->handle = mysql_connect();
	}
	public function disconect() {
		mysql_disconect();
	}
	public function query($query) {
		return mysql_query($query);
	}
}

Das ganze ist aber jetzt recht "nutzlos", da wir spätestens mit Datenbank::query() wieder in kontakt mit der eigentlichen Datenbank kommen würden. (Resultset) Das kann man vermeiden in dem man zb nicht das Resultset zurück gibt sondern die Daten in einen Array packt und diese zurückgibt. Ist aber nicht sehr schön. Weil was ist ein Resultset eigentlich? Wenn du jetzt Objekt gesagt hast -> 100Punkte. Hier mal der abgeänderte Code...

PHP:
class Datenbank {
	private $handle;
	
	public function connect() {
		$this->handle = mysql_connect();
	}
	public function disconect() {
		mysql_disconect();
	}
	public function query($query) {
		return new Datenbank_result(mysql_query($query));
	}
}

class Datenbank_result {
	private $result;
	
	public function __construct($result) {
		$this->result = $result;
	}
	
	public function isValid() {
		return (boolean)$this->result;
	}
	
	public function count() {
		return mysql_num_rows($this->result);
	}
	
	public function reset() {
		$this->seek(0);
	}
	
	public function next() {
		return mysql_fetch_assoc($this->result);
	}
	
	public function seek($pos) {
		mysql_data_seek($this->result,$pos);
	}
}


Das ganze könnte man jetzt so verwenden:

PHP:
$db = new Datenbank;
$db->connect();
$result = $db->query("SELECT feld1, feld2 FROM foo WHERE 1 = 1");
if($result->count() == 0) {
	echo "nix gefunden";
} else {
	while($daten = $result->next()) {
		var_dump($daten);
	}
}

Das ganze kann man jetzt noch weiter verfeinern... zb der eigentliche Query ist prinzipiell auch ein Objekt. Könnte dann so aussehen:
PHP:
class Datenbank {
	private $handle;
	
	public function connect() {
		$this->handle = mysql_connect();
	}
	public function disconect() {
		mysql_disconect();
	}
	public function query(Datenbank_query $query) {
		return new Datenbank_result(mysql_query("$query"));
	}
}

class Datenbank_result {
	private $result;
	
	public function __construct($result) {
		$this->result = $result;
	}
	
	public function isValid() {
		return (boolean)$this->result;
	}
	
	public function count() {
		return mysql_num_rows($this->result);
	}
	
	public function current() {
		return mysql_fetch_assoc($this->result);
	}
	
	public function reset() {
		$this->seek(0);
	}
	
	public function next() {
		return mysql_fetch_assoc($this->result);
	}
	
	public function seek($pos) {
		mysql_data_seek($this->result,$pos);
	}

}

class Datenbank_query {
	private $fields = array(),
		$table,
		$where;
		
	public function addField($field) {
		$this->fields[] = $field;
	}
	
	public function addFields(Array $fields) {
		$this->fields = array_merge($this->fields,$fields);
	}
		
	public function table($table) {
		$this->table = $table;
	}
	
	public function where($where) {
		$this->where = $where;
	}

	public function __toString() {
		return "SELECT ".implode(',',$this->fields)." FROM {$this->table} WHERE {$this->where}";
	}

}


$db = new Datenbank;
$db->connect();

$query = new Datenbank_query();
$query->table('foo');
$query->fields(array('feld1','feld2'));
$query->where('1 = 1');
$result = $db->query($query);
if($result->count() == 0) {
	echo "nix gefunden";
} else {
	while($daten = $result->next()) {
		var_dump($daten);
	}
}

Oder das ganze mal andersrum... du erstellst den Query und führst ihn dann direkt aus was irgendwo logischer ist. Das ganze ist aber im endeffekt egal... das kann man machen wie man möchte. (diese Variante würde aber vorteile bringen wenn man mit verschiedenen Datenbanken arbeitet.)

PHP:
class Datenbank {
	private $handle;
	
	public function connect() {
		$this->handle = mysql_connect();
	}
	public function disconect() {
		mysql_disconect();
	}
	public function query(Datenbank_query $query) {
		return new Datenbank_result(mysql_query("$query"));
	}
}

class Datenbank_result {
	private $result;
	
	public function __construct($result) {
		$this->result = $result;
	}
	
	public function isValid() {
		return (boolean)$this->result;
	}
	
	public function count() {
		return mysql_num_rows($this->result);
	}
	
	public function current() {
		return mysql_fetch_assoc($this->result);
	}
	
	public function reset() {
		$this->seek(0);
	}
	
	public function next() {
		return mysql_fetch_assoc($this->result);
	}
	
	public function seek($pos) {
		mysql_data_seek($this->result,$pos);
	}

}

class Datenbank_query {
	private $db;
	
	private $fields = array(),
		$table,
		$where;
	
	public function __construct(Datenbank $db) {
		$this->db = $db;
	}
	
	public function addField($field) {
		$this->fields[] = $field;
	}
	
	public function addFields(Array $fields) {
		$this->fields = array_merge($this->fields,$fields);
	}
		
	public function table($table) {
		$this->table = $table;
	}
	
	public function where($where) {
		$this->where = $where;
	}
	
	public function execute() {
		return $this->db->query("$this");
	}
	
	public function __toString() {
		return "SELECT ".implode(',',$this->fields)." FROM {$this->table} WHERE {$this->where}";
	}

}


$db = new Datenbank;
$db->connect();

$query = new Datenbank_query($db);
$query->table('foo');
$query->fields(array('feld1','feld2'));
$query->where('1 = 1');
$result = $query->execute();

if($result->count() == 0) {
	echo "nix gefunden";
} else {
	while($daten = $result->next()) {
		var_dump($daten);
	}
}

Das ganze soll nur als Beispiel diennen. Deswegen ist das ganze nicht wirklich funktionell... ist zwar möglich würde aber viel mehr Zeit kosten.

Vielleicht noch ein kleines Beispiel für Vererbung weils sich grade so gut anbietet. Mit der Klasse Datenbank_query kann man Queries erzeugen, also auch Queries erzeugen die Daten aus beliebigen Tabellen auslesen oder ändern. Mal angenommen du hast eine Tabelle User... jetzt könnte man die Klasse Query ableiten und eine neue Klasse erzeugen die spezielle für die Tabelle User zugeschnitten ist.

PHP:
class Table_user extends Datenbank_query {
	
	public function __construct($db) {	
		$this->table = 'user';
		$this->addField('*');
		
		base::__construct($db);
	}
	
	public function getAll() {
		$return $this->execute();
	}
	
	public function getUser($user_id) {
		$this->where("user_id = '$user_id'");
	}

	public function getByCity($city) {
		$this->where("city = '$city'");
		$return $this->execute();
	}

	public function getByEMail($email) {
		$this->where("email = '$email'");
		$return $this->execute();
	}
	
	public function getByName($name) {
		$this->where("name = '$name'");
		$return $this->execute();
	}
		
	public function delUser($user_id) {
		//geht nicht weil Datenbank_query so nur SELECTs kann
	}
	
	public function newUser($user_name,$passwort,...) {
		//geht nicht weil Datenbank_query so nur SELECTs kann
	}
}

$db = new Datenbank;
$db->connect();

$users = new Table_user($db);
$result = $users->getAll();
while($daten = $result->next()) {
	var_dump($daten);
}

if($result->count() == 0) {
	echo "nix gefunden";
} else {
	while($daten = $result->next()) {
		var_dump($daten);
	}
}

Ob das alles in der Form sinnvoll ist muss man selbst rausfinden. Das lernt man nur durch DOING ;) Zb bei einigen Projekten würde ich manche Sachen die ich hier geschreiben hab durchaus als sinnvoll erachten... in anderen Projekten wäre das zum Teil nur unnütz.