Ankündigung

Einklappen
Keine Ankündigung bisher.

Exception-Typen in Sub-Klassen

Einklappen

Neue Werbung 2019

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

  • Exception-Typen in Sub-Klassen

    Wie löst ihr das Problem, dass es in Sub-Klassen nicht mehr Exception-Typen geben darf als in deren Parent-Klassen?

    Ich habe zwar Ideen dazu, aber keine macht mich wirklich glücklich.


  • #2
    Inserate, Konzepte und Meinungsumfragen
    --

    „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


    • #4
      Das ist eine der Grundregeln der Vererbung. Die weiteren betreffen die Vorbedingungen, die Nachbedingungen und die history constraints.

      Hier mal die Kurzfassung für das Szenario Klasse U erbt von Klasse T:

      - Vorbedingungen:

      Vorbedingungen in U dürfen nicht stärker sein als in T.

      - Nachbedingungen:

      Nachbedingungen in U dürfen nicht schwächer sein als in T.

      - Exceptions:

      U darf nicht mehr Exception-Typen werfen als T.

      - history contraints:

      U kann mehr Aufrufreihenfolgen erlauben als T.

      Kommentar


      • #5
        Woher hast du das? Solche Beschreibungen sind mir noch nie über den Weg gelaufen. Vermutlich reden wir vom gleichen und nennen es anders.

        Kannst du mal konkrete Beispiele für dein Problem bringen?
        Lerne Grundlagen | Schreibe gute Beispiele | PDO > mysqli > mysql | Versuch nicht, das Rad neu zu erfinden | Warum $foo[bar] böse ist | SQL Injections | Hashes sind keine Verschlüsselungen! | Dein E-Mail Regex ist falsch

        Kommentar


        • #6
          http://de.wikipedia.org/wiki/Prinzip...tutionsprinzip
          --

          „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


          • #7
            Das ist in der Theorie ja ganz nett, aber zeig mir mal eine Software, wo das 100% umgesetzt wird.
            Lerne Grundlagen | Schreibe gute Beispiele | PDO > mysqli > mysql | Versuch nicht, das Rad neu zu erfinden | Warum $foo[bar] böse ist | SQL Injections | Hashes sind keine Verschlüsselungen! | Dein E-Mail Regex ist falsch

            Kommentar


            • #8
              Hey, offene Türen. Aber Du hast gefragt.
              --

              „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


              • #9
                Klar. Also um die Frage im Thread zu beantworten: Garnicht, weil keine praktische Relevanz :P
                Lerne Grundlagen | Schreibe gute Beispiele | PDO > mysqli > mysql | Versuch nicht, das Rad neu zu erfinden | Warum $foo[bar] böse ist | SQL Injections | Hashes sind keine Verschlüsselungen! | Dein E-Mail Regex ist falsch

                Kommentar


                • #10
                  Die erwähnten Grundregeln sind im übrigen nur Konzepte und Empfehlungen.
                  [URL="https://gitter.im/php-de/chat?utm_source=share-link&utm_medium=link&utm_campaign=share-link"]PHP.de Gitter.im Chat[/URL] - [URL="https://raindrop.io/user/32178"]Meine öffentlichen Bookmarks[/URL] ← Ich habe dir geholfen ? [B][URL="https://www.amazon.de/gp/wishlist/348FHGUZWTNL0"]Beschenk mich[/URL][/B].

                  Kommentar


                  • #11
                    Aber die Regeln machen Sinn. Hier ein Beispiel für Vorbedingungen:

                    PHP-Code:
                    <?php
                       error_reporting
                    (~0);
                       class 
                    T
                       
                    {
                          
                    /**
                           * @param num $v float oder int
                           */
                          
                    function set($v)
                          {
                             
                    // interner Check, ob die Vorbedingung eingehalten wurde:
                             
                    if(!is_numeric($v))
                                throw new 
                    InvalidArgumentException('v');
                          }
                       }
                       class 
                    extends T
                       
                    {
                          
                    /**
                           * @param int $v Widerspricht der Regel für Vorbedingungen
                           */
                          
                    function set($v)
                          {
                             
                    // interner Check, ob die Vorbedingung eingehalten wurde:
                             
                    if(!is_int($v))
                                throw new 
                    InvalidArgumentException('v');
                          }
                       }
                       class 
                    Main
                       
                    {
                          
                    /**
                           * @param T $o kann eine Instanz von T oder von U sein.
                           */
                          
                    function m(T $o)
                          {
                             
                    $v 1.1;
                             
                    $o->set($v);
                          }
                       }
                       
                       
                    $main = new Main();
                       
                       
                    // Test mit T:
                       
                    $t = new T();
                       
                    $main->m($t); // Test OK
                       
                       // Test mit U:
                       
                    $u = new U();
                       
                    $main->m($u); // Test NOK
                    ?>
                    Und hier ein Beispiel für Nachbedingungen:
                    PHP-Code:
                    <?php
                       error_reporting
                    (~0);
                       class 
                    T
                       
                    {
                          
                    /**
                           * @return int
                           */
                          
                    function get()
                          {
                             return 
                    1;
                          }
                       }
                       class 
                    extends T
                       
                    {
                          
                    /**
                           * @return num int oder float Widerspricht der Regel für Nachbedingungen
                           */
                          
                    function get()
                          {
                             return 
                    1.1;
                          }
                       }
                       class 
                    Main
                       
                    {
                          function 
                    m(T $o)
                          {
                             
                    $v $o->get();
                             
                             
                    // interner Check, ob die Nachbedingung eingehalten wurde:
                             
                    if(!is_int($v))
                                throw new 
                    Exception('v');
                                
                             echo 
                    'ok';
                          }
                       }
                       
                       
                    $main = new Main();
                       
                       
                    // Test mit T:
                       
                    $t = new T();
                       
                    $main->m($t); // Test OK
                       
                       // Test mit U:
                       
                    $u = new U();
                       
                    $main->m($u); // Test NOK
                    ?>

                    Kommentar


                    • #12
                      Klar machen sie Sinn. Man bricht aber nicht in jedem Fall mit der Exception-Empfehlung wenn man unterschiedliche Exceptions ( die voneinander Erben ) auf unterschiedlichen Layern der Klasse benutzt. Auch Interfaces im Bezug auf Exceptions helfen dabei nicht aus den Exceptions der untersten Ebene auszubrechen.

                      Software-Produkte die sich annähernd strict an die LSP-Recommendations halten sind im übrigen Symfony und Laravel. Geh jetzt bitte nicht hin und sag mir das Frameworks keine Software-Produkte sind.
                      [URL="https://gitter.im/php-de/chat?utm_source=share-link&utm_medium=link&utm_campaign=share-link"]PHP.de Gitter.im Chat[/URL] - [URL="https://raindrop.io/user/32178"]Meine öffentlichen Bookmarks[/URL] ← Ich habe dir geholfen ? [B][URL="https://www.amazon.de/gp/wishlist/348FHGUZWTNL0"]Beschenk mich[/URL][/B].

                      Kommentar


                      • #13
                        Sorry aber die Beispiele sind so dermaßen konstruiert, da fehlt jedweder Bezug zur Realität.
                        Lerne Grundlagen | Schreibe gute Beispiele | PDO > mysqli > mysql | Versuch nicht, das Rad neu zu erfinden | Warum $foo[bar] böse ist | SQL Injections | Hashes sind keine Verschlüsselungen! | Dein E-Mail Regex ist falsch

                        Kommentar


                        • #14
                          Hier noch der Vollständigkeit halber ein Beispiel mit Exceptions:
                          PHP-Code:
                          <?php
                             error_reporting
                          (~0);
                             class 
                          T
                             
                          {
                                
                          /**
                                 * @param int $v
                                 * @throws InvalidArgumentException
                                 */
                                
                          function m($v)
                                {
                                   if(!
                          is_int($v))
                                      throw new 
                          InvalidArgumentException('v');
                                }
                             }
                             class 
                          extends // irgendwann später hinzugekommen
                             
                          {
                                const 
                          MAX 5;
                                
                          /**
                                 * @param int $v
                                 * @param InvalidArgumentException
                                 * @throws OutOfRangeException
                                 */
                                
                          function m($v)
                                {
                                   if(!
                          is_int($v))
                                      throw new 
                          InvalidArgumentException('v');
                                      
                                   if(
                          $v self::MAX)
                                      throw new 
                          OutOfRangeException('v'); // Widerspricht der Regel für Exception-Typen
                                
                          }
                             }
                             class 
                          Main // stellvertretend für vielleicht zig andere Klassen, die mit T bzw U arbeiten
                             
                          {
                                function 
                          m(T $o)
                                {
                                   try
                                   {
                                      
                          $v 10;
                                      
                          $o->m($v);
                                   }
                                   catch(
                          InvalidArgumentException $o)
                                   {
                                      
                          var_dump($o);
                                   }
                                }
                             }
                             
                             
                          $main = new Main();
                             
                             
                          // Test mit T:
                             
                          $t = new T();
                             
                          $main->m($t); // Test OK
                             
                          echo 'ok';
                             
                             
                          // Test mit U:
                             
                          $u = new U();
                             
                          $main->m($u); // Test NOK
                          ?>
                          Ein Beispiel zu history contrains erspare ich mir. Ist mir zu kompliziert.

                          Kommentar


                          • #15
                            Dann catche ich halt beide Exceptions. Wo ist das Problem?
                            Lerne Grundlagen | Schreibe gute Beispiele | PDO > mysqli > mysql | Versuch nicht, das Rad neu zu erfinden | Warum $foo[bar] böse ist | SQL Injections | Hashes sind keine Verschlüsselungen! | Dein E-Mail Regex ist falsch

                            Kommentar

                            Lädt...
                            X