(?) Vereinfachung von set und get Methoden

[Antz]

Servus.
Ein Klasse in der man viele Eigenschaften änden und auslesen können soll wird normalerweise wie folgt realisiert (vereinfacht dargestellt):

class Klasse
{
    private $_eigenschaft1 = null;
    private $_eigenschaft2 = null;
    private $_eigenschaft3 = null;

    // [...]

    public function setEigenschaft1($var)
    {
        $this->_eigenschaft1 = $var;
        return $this;
    }


    public function setEigenschaft2($var)
    {
        $this->_eigenschaft2 = $var;
        return $this;
    }

    // [....]


    public function getEigenschaft1()
    {
        return $this->_eigenschaft1;
    }


    public function getEigenschaft2()
    {
        return $this->_eigenschaft2;
    }

    // [...]
}

$Klasse = new Klasse();

$Klasse->setEigenschaft1('string text 1')
       ->setEigenschaft2('string text 2');

echo $Klasse->getEigenschaft1();

// Ausgabe:
string text 1 

Es ist jedoch auch folgendes möglich (vereinfacht dargestellt):

class Klasse
{
    private $_eigenschaft1 = null;
    private $_eigenschaft2 = null;
    private $_eigenschaft3 = null;

    // [...]

    /**
     * @param1  object  $par1  Eigenschaftsobjekt der Klasse
     * @param2  string  $par2  Wert der Eigenschaft der Klasse
     */
    public function set($par1, $par2)
    {
        $this->$par1 = $par2;
        return $this;
    }

    /**
     * @param  object  $par  Eigenschaftsobjekt der Klasse
     * @return  string
     */
    public function get($par)
    {
        return $this->$var;
    }
}

$Klasse = new Klasse();

$Klasse->set('_eigenschaft1', 'string text 1')
       ->set('_eigenschaft2', 'string text 2');

$Klasse->get('_eigenschaft1');

// Ausgabe
string text 1 

Die Frage ist jetzt, da dies so funktioniert ob es eine elegantere, oder, wenn das oben falsch ist, eine richtige Variante davon gibt. Und wie man eine Sicherung einbauen kann wenn z.B. $Klasse->set('_eigenschaft'); eingibt, aber in der Klasse keine Eigenschaft _eigenschaft existiert.

[Christian Marquardt]

Sicherlich ist das nicht der richtige Weg. U.a. aus den schon von dir angegebenen Gründen.

Vielmehr erzeugt man einen Konstruktor, dem man die Eigenschaften übergibt

[Falk Prüfer]

Hallo,

für solche Fälle und das transparente "Verstecken" von Public-Eigenschaften hinter Set- und Get-Methoden, bietet PHP s.g. "Magische Methoden" an.
Mit dem Auslösen einer Exception kann man dort auch auf das Nichtvorhandensein einer Eigenschaft reagieren.

<?php

class myTest
{
  private $_propertyA = null;
  private $_propertyB = null;

  public function __get($pProperty)
  {
    echo 'Using magic __Get<br />';
    switch ($pProperty) {
      case 'propertyA':
        return $this->_propertyA;
        break;
      case 'propertyB':
        return $this->_propertyB;
        break;
      default:
        throw new Exception('Eigenschaft '.$pProperty.' existiert nicht!');
    }
  }

  public function __set($pProperty, $pValue)
  {
    echo 'Using magic __Set<br />';
    switch ($pProperty) {
      case 'propertyA':
        $this->_propertyA = $pValue;
        break;
      case 'propertyB':
        $this->_propertyB = $pValue;
        break;
      default:
        throw new Exception('Eigenschaft '.$pProperty.' existiert nicht!');
    }
  }
}

$TestInstance = new myTest();

try {
  $TestInstance->propertyA = 'Hallo Welt!';
  $TestInstance->propertyB = 'Hallo World!';

  echo 'propertyA: '.$TestInstance->propertyA.'<br />';
  echo 'propertyB: '.$TestInstance->propertyB.'<br />';

  echo 'propertyC: '.$TestInstance->propertyC.'<br />';
} catch (Exception $e) {
  echo $e->getMessage();
}

Gruß Falk

[Antz]

Wao!
Danke, ich habe mir schon gedacht, dass ich das mit den magischen Methoden realisieren muss, aber bisweilen nicht ganz durchschaut. Ich schau mir das jetzt nochmal genauer an.

Vielleicht wärs du so nett und schaust dir auch noch folgenden Beitrag (wohl eher wieder eine Frage) von mit an. Wenn ich das dann verstanden habe, habe ich, denke ich, erstmal alles was ich wissen musste.

Zum Beitrag: http://entwickler-forum.de/showpost....19&postcount=1

[Antz]

Öhm mal ne Frage.

try {
  $TestInstance->propertyA = 'Hallo Welt!';
  $TestInstance->propertyB = 'Hallo World!';

  echo 'propertyA: '.$TestInstance->propertyA.'<br />';
  echo 'propertyB: '.$TestInstance->propertyB.'<br />';

  echo 'propertyC: '.$TestInstance->propertyC.'<br />';
} catch (Exception $e) {
  echo $e->getMessage(); 

Worin besteht den der eigendliche Unterschied zwischen den magischen Methoden und einem direkten Ansprechen der Variable?

In deinem Beispiel sind zwar die Klassen-Variablen als private deklariert und du kannst eine Belgen oder eine Abfragen einer Klassen-Variable abfangen, wenn sie nicht existiert. Ok, aber wenn ich die Klassen-Variablen als public deklariere kann ich das auch. Worin besteht denn der Unterschied. Warum macht man das mit magischen Methoden und nciht anders?

[Falk Prüfer]

Hallo,

wenn es nur darum geht eine Variable mit einem Wert zu belegen und auch nur diesen auzulesen, dann kann man diese Variable auch als public deklarieren. Sinn eines SETters bzw. GETters ist es jedoch weitere Funktionalität beim Setzen bzw. Auslesen einer Eigenschaft zu implementieren. So ist mein Beispiel eben nur beispielhaft (wie schön ) und darum auch sehr einfach.
Wenn ich jetzt meine Klasse myTest jedoch darauf umstelle, die Werte nicht einfach in private Eigenschaften zu speichern, sondern z.B. in einer Datenbank, dann könnte ich die Klasse abändern ohne den Code, der diese Klasse verwendet, ändern zu müssen.

class myTest
{
  public function __get($pProperty)
  {
    echo 'Using magic __Get<br />';
    switch ($pProperty) {
      case 'propertyA':
      case 'propertyB':
        return leseWertAusDatenbank($pProperty);
        break;
      default:
        throw new Exception('Eigenschaft '.$pProperty.' existiert nicht!');
    }
  }

  public function __set($pProperty, $pValue)
  {
    echo 'Using magic __Set<br />';
    switch ($pProperty) {
      case 'propertyA':
      case 'propertyB':
        schreibeWertInDatenbank($pProperty, $pValue);
        break;
      default:
        throw new Exception('Eigenschaft '.$pProperty.' existiert nicht!');
    }
  }
} 

Gruß Falk

[Christian Marquardt]

Getter/Setter: Vorraniger Zweck ist es m.E. die Änderung an X-Orten im Programm zu verhindern (wenn die Variable public ist) und einen Einsteigs- Aussteigspunkt zu haben

[Antz]

Ok, soweit klar, aber wenn du mit den __get und __set Methoden aufrufst, die vermutlich dann als private deklariert worden sind, könnte ich diese auch direkt pubic machen. Sicher, du kannst an einem zentralen Punkt in der Klasse alle Änderungen machen, als so eine Art Interface...
So ganz versteh ich den Sinn doch noch nicht dahinter.

[Christian Marquardt]

Das ist eine zentrales Vorgehen in der OOP. Membervariablen sind nach außen hin nie sichtbar und haben Getter/Setter, weil

- Überprüfung der Werte
- keine unkontrollierten Änderungen
- du kannst ggf. die Variable oder das dahinterliegende Objekt ändern, ohne das die die das aufrufen etwas davon mitbekommen
- ggf. auch den Wert überhaupt beim GET berechnen