Suchen
Inside Wiki
Nützliche Links




 
phpforum.de bei Facebook
 
phpforum.de bei Twitter
 

Zurück   PHP Forum: phpforum.de > phpforum.de Wiki > phpforum.de Wiki

PHP Wiki Dieses Wiki sammelt Lösungen, zu Problemen, welche immer wieder im Forum auftauchen.

 
 
Artikel-Optionen Ansicht
  #1  

Standard Overloading

 

Inhalte

Was ist Overloading?


Als Overloading(engl. Überladen) bezeichnet man das Zugreifen auf (Pseudo)Eigenschaften und (Pseudo)Methoden einer Klasse, die nicht definiert sind. Ein Beispiel für Overlaoding ist die Klasse Zend_Config des Zend Frameworks. Dort werden Konfigurationsdateien in ein Objekt eingelesen und verfügbar gemacht. Die Konfigurationseinstellung mit dem Namen "user" wäre dann über $objekt->user verfügbar, obwohl sie vorher nicht explizit über "public $user" definiert ist.

Vorgehensweise


Das Überladen geschieht in PHP mit magischen Funktionen. Das sind besondere Funktionen, die in jeder Klasse definiert sein können. Sie haben jeweils einen festen Namen und eine feste Anzahl an Parameter, die von PHP dann automatisch befüllt werden.

Eigenschaften


Eigenschaften kann man zum lesen und zum schreiben überladen.

Lesen


Um Eigenschaften zum lesen zu überladen gibt es die magische Funktion __get(). Sie erwartet als Argument den Namen der Eigenschaft, die überladen wird.
PHP Quellcode:
//Klasse definieren
class overloading
{
    //Array, indem wir unsere Werte speichern
    public $array = array();
    //Magische Methode
    public function __get ($eigenschaft)
    {
       //Überprüfen, ob der Key $eigenschaft existiert
       if(isset($this->array[$eigenschaft]))
       {
           return $this->array[$eigenschaft];
       }
       else
       {
           return false;
       }
    }
}

//Objekt erzeugen
$obj = new overloading;
//Werte in das Objekt schreiben
$obj->array = array('a'=>'A', 'b'=>'B', 'ich'=>'du');
//Überladen
echo $obj->a; //gibt A
echo $obj->b; //gibt B
echo $obj->ich; //gibt du

Die Methode __get wird also immer dann aufgerufen, wenn wir auf eine Eigenschaft zugreifen wollen, die nicht existiert.

Schreiben


Um Eigenschaften schreibend zu überladen, gibt es die magische Methode __set(). Sie erwartet als Argument den Namen der Eigenschaft und deren neuen Wert. __set wird immer dann aufgerufen, wenn eine Eigenschaft geschrieben wird, die nicht existiert.
Wir erweitern die obige Klasse.
PHP Quellcode:
//Klasse definieren
class overloading
{
    //Array, indem wir unsere Werte speichern
    public $array = array();
   
    //Magische Methode zum lesenden Überladen
    public function __get ($eigenschaft)
    {
       //Überprüfen, ob der Key $eigenschaft existiert
       if(isset($this->array[$eigenschaft]))
       {
           return $this->array[$eigenschaft];
       }
       else
       {
           return false;
       }
    }
    //Magische Methode zum schreibenden Überladen
    public function __set($eigenschaft, $wert)
    {
        //Hinzufügen eines Schlüssels zum array $this->array
        $this->array[$eigenschaft] = $wert;
    }
}

//Objekt erzeugen
$obj = new overloading;
//Werte in das Objekt schreiben
$obj->array = array('a'=>'A', 'b'=>'B', 'ich'=>'du');
//Überladen(lesen)
echo $obj->a; //gibt A
echo $obj->b; //gibt B
echo $obj->ich; //gibt du
//Überladen(schreiben)
$obj->hunger = 'hamburger';
$obj->durst = 'cola';
//Auslesen der eben geschriebenen Werte durch lesende Überladung
echo $obj->hunger; //gibt hamburger
echo $obj->durst; //gibt cola

Methoden


Auch Methoden können überladen werden. Dabei können (Pseudo)Methoden aufgerufen werden die nicht über "public function methode" definiert sind. Dazu existiert die magische Funktion __call, die als Parameter den Namen der Methode erwartet und ein Array mit allen Funktionsparametern. Die Methode __call wird als immer dann von PHP automatisch aufgerufen, wenn man versucht auf eine Methode zuzugreifen, die nicht existiert.
PHP Quellcode:
<?php
//Klasse definieren
class overloading
{
    //Magische Methode zum Überladen von Methoden
    public function __call($methode, $argumente)
    {
        //Zurückgeben des Methodennamens und aller Argumente
        return $methode . ' ' . print_r($argumente, true);
    }
}

//Objekt erzeugen
$obj = new overloading;

//Überladen
echo $obj->eineMethode('Hallo. Ich existiere eigentlich nicht!');
echo $obj->etwasAnderes('Hallo', 'mir', 'kann', 'man beliebig', 'viele Argumente mitgeben.', 1, 5, 8, true, false);

Das Beispiel erzeugt folgende Ausgabe:
Code:
eineMethode Array
(
    [0] => Hallo. Ich existiere eigentlich nicht!
)
etwasAnderes Array
(
    [0] => Hallo
    [1] => mir
    [2] => kann
    [3] => man beliebig
    [4] => viele Argumente mitgeben.
    [5] => 1
    [6] => 5
    [7] => 8
    [8] => 1
    [9] =>
)

Überladen mit Arraysyntax


Auf Objekte kann man auch mittels der ganz normalen Arraysyntax zugreifen($array['schluessel']). Dazu existiert ein interface mit dem Namen ArrayAccess. Um es zu benutzen muss man vier Methoden in seiner Klasse definieren: offsetExists, offsetGet, offsetSet und offsetUnset. An folgender Klasse wird die Vorgehensweise deutlich.
PHP Quellcode:
//Klasse definieren
class overloading implements ArrayAccess
{
   public $array = array('a'=>'1', 'b'=>2, 'c'=>3);
   
   // offsetExists musss einen boolschen Wert zurückgeben. Die Funktion muss überprüfen, ob ein Schlüssel existiert
   public function offsetExists($schluessel)
   {
       if(isset($this->array[$schluessel]))
       {
           return true;
       }
       else
       {
           return false;
       }
   }
   
   //offsetGet gibt den Wert eines Arrayelements zurück
   public function offsetGet($schluessel)
   {
       return $this->array[$schluessel];
   }
   
   //offsetSet weist einem Arrayelement einen neuen Wert zu
   public function offsetSet($schluessel, $wert)
   {
       $this->array[$schluessel] = $wert;
   }
   
   //offsetUnset löscht einen Arrayschlüssel
   public function offsetUnset($schluessel)
   {
       unset($this->array[$schluessel]);
   }
}

//Objekt erzeugen
$obj = new overloading;
//Die Methode offsetExists wird aufgerufen
var_dump(isset($obj['a']));
//Die Methode offsetGet wird aufgerufen
var_dump($obj['a']);
//Die Methode offsetSet wird aufgerufen
$obj['a'] = 44;
var_dump($obj['a']);
//Die Methode offsetUnset wird aufgerufen
unset($obj['a']);
//$obj['a'] existiert nicht mehr

Das Script erzeugt folgende Ausgabe:
Code:
bool(true)
string(1) "1"
int(44)

Links



Mitwirkende: Sebbl
Erstellt von Sebbl, 08.04.2008 am 21:10
Zuletzt bearbeitet von Sebbl, 08.04.2008 am 21:10
5 Kommentare , 3895 Betrachtungen

Dieser Text steht unter der GNU-Lizenz für freie Dokumentation


 

Lesezeichen

Artikel-Optionen
Ansicht

Forumregeln
Es ist Ihnen nicht erlaubt, neue Themen zu verfassen.
Es ist Ihnen nicht erlaubt, auf Beiträge zu antworten.
Es ist Ihnen nicht erlaubt, Anhänge hochzuladen.
Es ist Ihnen nicht erlaubt, Ihre Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.

Gehe zu

Alle Zeitangaben in WEZ +2. Es ist jetzt 15:14 Uhr.


Powered by vBulletin® Version 3.8.8 (Deutsch)
Copyright ©2000 - 2018, Jelsoft Enterprises Ltd.
Powered by NuWiki v1.3 RC1 Copyright ©2006-2007, NuHit, LLC