Ankündigung

Einklappen
Keine Ankündigung bisher.

Frage zu OOP und Interface

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Frage zu OOP und Interface

    Moin Leude,

    ich les grad das buch "php endlich objektorientiert" und den OOP-Teil , genauer den Abschnitt wo es um Interfaces geht.
    Eine zweite Klasse kann eine Referenz auf das Interface besitzen und dann ein Objekt der
    Klasse anlegen
    , die das Interface implementiert. Über die Referenz auf das Interface können die dort deklarierten Methoden dann verwendet werden.
    Die 2 unverständlichen Texte hab ich mal markiert. Wie genau sieht das in PHP aus?
    Ich versteh nicht wie das konkret aussehen soll. wie kann man eine Referenz zu einem Interface schaffen?
    Man kann doch nicht vom Interface instanzieren.
    Hat jemand ein minimalistisches Codebeispiel?

  • #2
    Lies dir mal das durch - PHP-Doku - mit Beispiel: http://php.net/manual/de/language.oop5.interfaces.php
    The string "()()" is not palindrom but the String "())(" is.

    Debugging: Finde DEINE Fehler selbst! | Gegen Probleme beim E-Mail-Versand | Sicheres Passwort-Hashing | Includes niemals ohne __DIR__
    PHP.de Wissenssammlung | Kein Support per PN

    Kommentar


    • #3
      Habe es mir angesehen, aber muss zugeben, dass ich noch nicht schlauer daraus geworden bin als zuvor.
      Was ich bisher verstanden habe:
      • Interfaces definieren Methoden ohne das diese ausformuliert werden.
      • Die Klasse die das Interface erbt muss diese Methoden implementieren.
      • Es kann von mehreren Interfaces geerbt werden.
      • Die Klassen funktionieren auch ohne diese Interfaces
      • In Klassen kann eine Methode definiert sein die eine Variable vom typ Interface statt z.b. der Instanz entgegennimmt
      Ist das letztere damit gemeint was mein Unverständnis war? Ich versteh dieses Fachchinesisch nicht so richtig obwohl ich mich schon ne Weile mit befasse.

      Was mir hier nicht klar ist, was die Autoren unter Referenz verstehen.
      Für mich war klar, das jede Variable die über new Klasse was instanziert quasi die Referenz ist aber was hat das mit dem Interface zu tun?

      Kommentar


      • #4
        Schau mal hier nikosch hat das einmal gut ausformuliert.. bzw. schau dir den Thread auch dort mal an.

        Zitat von nikosch Beitrag anzeigen
        Der grösste Vorteil von Interfaces liegt imho im Entwurfsstadium. Du schreibst etwas und weisst genau, dort wird später mal ein Objekt sitzen, welches das und das tut. Du weisst noch nicht, wie genau dieses Objekt arbeitet (Blackboxprinzip), aber Du weisst welche Ein- und Ausgaben es verarbeitet und definierst über die Schnittstelle, wie es angesprochen werden soll.

        2. Ein verwandter Vorteil: Du setzt ein modulares Konzept um, in dem Objekte austauschbar sein sollen. Mit einem Interface lieferst Du eine Schablone, wie die Blackbox des austauschbaren Objektes aussieht - egal wie es später was verarbeitet, oder was sich jemand mal für diesen Bereich ausdenkt, er hat einen konkreten Anhaltspunkt, wie sein Objekt nach aussen interagieren muss.

        3. In Frameworks sind Abhängigkeiten oft nicht ganz auszuschliessen. So übergibt man bspw. einem Objekt ein anderes als Datenspeicher. Wenn man bei der Übergabe ein konkretes Interface vorgibt, wird zumindest die alles bis auf die Schnittstelle unabhängig, da bereits das Interface das Vorhandensein bestimmter Zugriffsmethoden erzwingt.

        Mein kleiner Erklärungsansatz.
        The string "()()" is not palindrom but the String "())(" is.

        Debugging: Finde DEINE Fehler selbst! | Gegen Probleme beim E-Mail-Versand | Sicheres Passwort-Hashing | Includes niemals ohne __DIR__
        PHP.de Wissenssammlung | Kein Support per PN

        Kommentar


        • #5
          Das ist wirklich seltsam geschrieben^^

          Ich versuche mich mal an einem Beispiel was man mit Interfaces machen kann. Dafür nutze ich das Serialize-Interface um Daten eines Objekts in einen String zu schreiben (serialize) bzw. aus einem String zu nehmen (unserialize).

          PHP-Code:
          class Human implements Serializable {

              private 
          $firstname;
              private 
          $surname;
              private 
          $dateOfBirth;

              public function 
          __construct($firstname null$surname null$dateOfBirth null) {
                  
          $this->firstname $firstname;
                  
          $this->surname $surname;
                  
          $this->dateOfBirth $dateOfBirth;
              }

              public function 
          serialize() {
                  return 
          json_encode([
                      
          'firstname' => $this->firstname,
                      
          'surname' => $this->surname,
                      
          'dateOfBirth' => $this->dateOfBirth,
                  ]);
              }

              public function 
          unserialize($serialized) {
                  
          $data json_decode($serialized);
                  
          $this->firstname $data->firstname;
                  
          $this->surname $data->surname;
                  
          $this->dateOfBirth $data->dateOfBirth;
              }

          }

          class 
          Dog implements Serializable {

              private 
          $name;
              private 
          $age;

              public function 
          __construct($name null$age null) {
                  
          $this->name $name;
                  
          $this->age $age;
              }

              public function 
          serialize() {
                  return 
          json_encode([
                      
          'name' => $this->name,
                      
          'age' => $this->age,
                  ]);
              }

              public function 
          unserialize($serialized) {
                  
          $data json_decode($serialized);
                  
          $this->name $data->name;
                  
          $this->age $data->age;
              }


          Die Klassen Human und Dog implementieren das Serialize-Interface.
          Dann packen wir noch eine andere Klasse hinzu, die sich nur für das Interface, nicht für die konkrete Klasse interessiert.
          PHP-Code:
          class Writer {

              public function 
          printAnimal(Serializable $randomObject) {
                  print(
          $randomObject->serialize());
              }


          Jetzt nehmen wir uns ein paar Testdaten und erstellen ein Paar Objekte.
          PHP-Code:
          $serializedData = [
              [
          'type' => 'Human''data' => json_encode(['firstname' => 'Hans''surname' => 'Lumpi''dateOfBirth' => '1990-07-07'])],
              [
          'type' => 'Dog''data' => json_encode(['name' => 'Bobo''age' => 2])],
          ];
          $animals = [];
          foreach (
          $serializedData as $animalData) {
              
          $class = new $animalData['type']();
              if (
          $class instanceof Serializable) {
                  
          $class->unserialize($animalData['data']);
                  
          $animals[] = $class;
              }
          }
          var_dump($animals); 
          In Zeile 8 wird schon das erste mal Bezug auf das Interface genommen. Ich prüfe ob das Objekt im aktuellen Schleifendurchlauf das Interface implementiert, damit ich die entsprechende Methode aufrufen kann.
          Das ergebnis sieht so aus:
          Code:
          array (size=2)
            0 =>
              object(Human)[1]
                private 'firstname' => string 'Hans' (length=4)
                private 'surname' => string 'Lumpi' (length=5)
                private 'dateOfBirth' => string '1990-07-07' (length=10)
            1 =>
              object(Dog)[2]
                private 'name' => string 'Bobo' (length=4)
                private 'age' => int 2
          Die Tiere können wir jetzt einfach in den Writer werfen der uns die Daten dann ausgibt.
          PHP-Code:

          $writer 
          = new Writer();
          foreach (
          $animals as $animal) {
              
          $writer->printAnimal($animal);

          Code:
          {"firstname":"Hans","surname":"Lumpi","dateOfBirth":"1990-07-07"}{"name":"Bobo","age":2}
          Was das Beispiel verdeutlichen soll ist, dass du dich nich auf die konkreten Klassen konzentrieren musst. Statt auf das Interface zu prüfen könntest du sonst auch einfach prüfen ob das aktuelle Objekt die jeweilige Methode besitzt. Durch das Interface werden solche Dinge bereits implizit geregelt und können per Typ-Prüfungen und Typehints erschlagen werden.
          [COLOR=#A9A9A9]Relax, you're doing fine.[/COLOR]
          [URL="http://php.net/"]RTFM[/URL] | [URL="http://php-de.github.io/"]php.de Wissenssammlung[/URL] | [URL="http://use-the-index-luke.com/de"]Datenbankindizes[/URL] | [URL="https://www.php.de/forum/webentwicklung/datenbanken/111631-bild-aus-datenbank-auslesen?p=1209079#post1209079"]Dateien in der DB?[/URL]

          Kommentar

          Lädt...
          X