Ankündigung

Einklappen
Keine Ankündigung bisher.

Generics in PHP

Einklappen

Neue Werbung 2019

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

  • Generics in PHP

    Ich suche nach einer Methode, ein Teilkonzept der Generics aus Java zu imitieren. Genauer genommen versuche ich sowas:

    Code:
    public class Foo<SubClass extends MasterClass>
    {
        public void doSomething(SubClass subClass)
        {
             ...
        }
    }
    Ist es möglich dieses Konzept zu imitieren?


  • #2
    Ich mach das bei Klassen, die bestimmte Array-Elemente enthalten sollen immer mit einer checkElement() Methode, die eine Exception wirft, wenn das Objekt falsch ist. Anders wüsste ich nicht, wie man das Konzept so umsetzen sollte.
    "Mein Name ist Lohse, ich kaufe hier ein."

    Kommentar


    • #3
      Zitat von Chriz Beitrag anzeigen
      Ich mach das bei Klassen, die bestimmte Array-Elemente enthalten sollen immer mit einer checkElement() Methode, die eine Exception wirft, wenn das Objekt falsch ist. Anders wüsste ich nicht, wie man das Konzept so umsetzen sollte.
      Schade, könnte man nicht in jeder Oberklasse den Namen der Oberklasse hinterlegen und auf diesen hingehend prüfen? Also:

      PHP-Code:
      interface Masterable
      {
          public function 
      getClassName();
      }

      abstract class 
      Master implements Masterable
      {
          private 
      $className __CLASS__;

          public function 
      getClassName()
          {
              return 
      $this->className;
          }
      }

      class 
      Sub extends Master
      {
          ...
      }

      class 
      AnotherClass
      {
          public function 
      doSomething($obj)
          {
               if (!
      $obj->getClassName() == '...')
               {
                    throw new 
      Exception('...');
               }
          }

      Kommentar


      • #4
        Das geht in der Form nicht. Du kannst aber in PHP einfach zur Laufzeit prüfen ob der Datentyp passt.

        PHP-Code:
        class blub {
           private 
        $type null;

           public function 
        __consturct($type) {
              
        $this->type $type;
           }

           public function 
        add($value) {
              if(!
        $value instanceof $this->type) throw new Excpetion(...)
              ...
           }

        Kommentar


        • #5
          Zitat von erc Beitrag anzeigen
          Das geht in der Form nicht. Du kannst aber in PHP einfach zur Laufzeit prüfen ob der Datentyp passt.

          PHP-Code:
          class blub {
             private 
          $type null;

             public function 
          __consturct($type) {
                
          $this->type $type;
             }

             public function 
          add($value) {
                if(!
          $value instanceof $this->type) throw new Excpetion(...)
                ...
             }

          Kann denn instanceof auch auf Masterklassen angewendet werden? Also:

          PHP-Code:
          abstract class Master {}
          class 
          Sub extends Master {}

          $sub = new Sub();
          if (
          $sub instanceof Master)
          {
              
          // ...

          Kommentar


          • #6
            PHP: Type Operators - Manual

            Kommentar


            • #7
              Du kannst dir die IF-Abfrage und das Exception-Werfen auch sparen, in dem du Typehints vor die Parameter der Methoden setzt. Das funktioniert nicht nur für Masterklassen sondern auch für Interfaces.

              Kommentar


              • #8
                Da erklär mal, wie man dynamische Typehints macht :P

                Man bräuchte etwas, wie
                PHP-Code:
                ...
                public function 
                method(<$type$var)
                ... 

                Edit: Hab ne seite gefunden, wo ein generisches ArrayObject beschrieben wird.
                http://blog.maartenballiauw.be/post/...ys-in-PHP.aspx
                vll hilft dir das weiter.

                Kommentar


                • #9
                  He das is mein Ansatz! So in etwa mach ichs auch, wobei ich gemerkt hab, dass append() nur an offsetSet() weitergeleitet und ich mir irgendwann ne Endlosschleife reingeschossen hab.

                  Hier mein Code:
                  PHP-Code:
                  <?php
                  abstract class PHPWord_Util_ArrayIterator_Abstract extends ArrayIterator
                  {
                      
                  /**
                       * @param mixed $element
                       * @return bool
                       */
                      
                  abstract protected function _isArrayIteratorElement($element$key);

                      public function 
                  __construct(Traversable $elements null)
                      {
                          if (
                  $elements !== null) {
                              foreach (
                  $elements as $offset => $element) {
                                  
                  $this->offsetSet($offset$element);
                              }
                          }
                      }
                      
                      public function 
                  toArray()
                      {
                          return 
                  $this->getArrayCopy();
                      }

                      public function 
                  append($element)
                      {
                          
                  $this->_checkArrayIteratorElement($elementnull);
                          return 
                  parent::offsetSet(null$element);
                      }

                      public function 
                  offsetSet($offset$element)
                      {
                          
                  $this->_checkArrayIteratorElement($element$offset);
                          return 
                  parent::offsetSet($offset$element);
                      }
                      
                      public function 
                  offsetGet($offset)
                      {
                          return 
                  $this->offsetExists($offset)
                               ? 
                  parent::offsetGet($offset)
                               : 
                  null;
                      }
                      
                      
                  /**
                       * @deprecated
                       */
                      
                  public function last()
                      {
                          
                  $stop $this->count();
                          
                  $last null;
                          
                  $this->rewind();
                          while (
                  $this->next()) {
                              if (--
                  $stop == 0) {
                                  return 
                  $this->current();
                              }
                          }
                          return 
                  null;
                      }

                      protected function 
                  _checkArrayIteratorElement($element$key)
                      {
                          if (!
                  $this->_isArrayIteratorElement($element$key)) {
                              throw new 
                  InvalidArgumentException("invalid element");
                          }
                      }
                  }
                  "Mein Name ist Lohse, ich kaufe hier ein."

                  Kommentar


                  • #10
                    public class Foo<SubClass extends MasterClass>
                    {
                    public void doSomething(SubClass subClass)
                    {
                    ...
                    }
                    }
                    Verstehe den Plan irgendwie nicht.
                    --

                    „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                    Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


                    --

                    Kommentar

                    Lädt...
                    X