Polymorfisme is inderdaad het concept dat je een subklasse kunt benaderen alsof het een klasse van het type van de (een) parent is.

Voorbeeld:

interface Writeable {
public function save();
public function load();
}

class Parent {
...
public function doeJeDing() {
}
...
}

class Child extends Parent implements Writeable {
...
}

// main code
$oDing = new Child();
// dit mag nu
doeIetsMetWriteables($oDing);
// maar dit ook
doeIetsMetParent($oDing);

// functies die polymoprfisme gebruiken
function doeIetsMetWriteables(Writeable $p_oObject) {
$p_oObject->save();
}

function doeIetsMetParent(Parent $p_oObject) {
// doe iets
}

Om even verder op jouw idee te bouwen:

Op de manier kun je alle instanties en childs van DP_Model aan ModelProcess::Process() voeren. Alle childs van DP_Model hebben immers de methodes die DP_Model aanbiedt.

Ik ben sowieso niet zo'n fan van statische methodes zoals jij ze gebruikt aangezien je op deze manier een stuk flexibiliteit inlevert. Want, wanneer je User::add() gebruikt, is je code hard gebonden aan de user klasse en dat is niet altijd gewenst.

Hier ben ik het trouwens niet mee eens omdat bij 'niet-statisch' klassen dit wel zo gebeurd. Dit is volgens mij hetgene waar polymorfisme op gebasseerd is als ik me niet vergis. Dat de parent aan child members kan.

Ik maak hier gebruik van de fictieve constante 'child'.
(even aannemen dat self::$_db is geset in een soort van 'init' methode)
----
class DP_Model {
public static function add($data) {
self::_filter($data); self::$_db->insert(child::$_table, $data);
}

public static function update($data, $where, $quoteInto = array()) {
self::_filter($data);
self::$_db->updata(child::$_table, $data, $where, $quoteInto);
}

public static function delete($id) {
self::_filter($data);
if(child::$_hasDeleteColumn) {
self::$_db->update(child::$_table, array('deleted' => 1), 'id = ?', $id);
} else {
self::$_db->delete(child::$_table, $id);
}

public static function recover($id) {
if(child::$_hasDeletedColumn) {
self::$_db->update(child::$_table, array('deleted' => 0), 'id = ?', $id);
} else {
// error throwen of iets dergelijks
}

protected static function _filter(&$data) {
$data = array_intersect_key($data, array_flip(child::$_columns);
}
}
-----

En dan zal je heel toffe klassen hiervan kunnen extenden:

-----
class User extends DP_Model {
protected $_table= "user";
protected $_hasDeletedColumn = true;
protected $_columns = array('username', 'first_name', 'last_name', 'email', ...);
}

class ForumPost extends DP_Model {
protected $_table = "forum_posts";
protected $_hasDeletedColumn = true;
protected $_columns = array('owner', 'body_id', 'created');
}
-------

==>

-----
User::add(array('username' => 'a username', 'first_name' => 'Koen', 'last_name' => 'Speelmeijer', 'email' => '...', 'aNonExistantColumn' => 'value');
// die laatste wordt dan genegeerd
ForumPost::delete(5);
// enz enz enz
-----

Nu moet ik het zo doen:
----
User::instance()->add(....);
----

Is er trouwens een ubb code voor codes, omdat het er nu niet uitziet.
Hier heb ik ook even de code gepost voor de uitleining:
http://v2.pastebin.be/188

Dat gaat uiteraard niet gebeuren. Het idee is juist dat een overerfende klasse de parent uitbreidt. En niet dat de parent op wijzigingen in de childs bouwt.

Ik vraag me dan ook af in wat voor situatie je dit uberhaupt zou willen gebruiken :)

Als je een class overneemd dan worden die parent functies onderdeel van het child.

Dus als je op de child een functie uitvoerd van die komt van de parent dan ziet die functie gewoon de parent en child als een.
Alleen is het zo dat als de child een var of functie heeft die het zelfde heet als die van de parrent dan word die van de parent overschrijven maar kan je nog wel met parent:: aanroepen.

Of zo iets, in het donken typen met een zwarttoetsennboord naar niet samen :)

-----
class ParentClass {
public static function calledViaChild() {
return child::$_protectedVar;
}
}
class ChildClass1 extends ParentClass {
public static $_protectedVar = "foo";
}
class ChildClass2 extends ParentClass {
public static $_protectedVar = "bar";
}

echo ChildClass1::calledViaChild(); // foo
echo ChildClass2::calledViaChild(); // bar
------------
Zoiets is momenteel nog niet mogelijk voor zover ik weet.

http://www.stubbles.org/archives/8-My-wishlist-for-PHP-6,-pt3-Annotations.html