oop class extends vererbung / referenz

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

  • oop class extends vererbung / referenz

    hi
    ich benutze äußerst selten Klassen, bringt selten was, außer zeitverlust und die notwedigkeit das objekt hinterher aus dem speciher zu löschen...
    bei komplexeren sachen soll es aber schon mal vorkommen
    so z.B. jetzt:

    ich möchte für eine aufgabestellung mit etlichen methoden und membern unter-objekte erstellen, die die member des eltern-objektes vererbt bekommen. allerdings nicht die des objektes in codeauslieferung sondern nach modifikation on runtime. hmm - so wirds deutlicher -->

    PHP-Code:
    class elter {
      public 
    $var;

      function 
    nkind() {
        
    $this->kind = new kind();
      }

      function 
    show() {
        echo 
    $this->var;
      }
    }

    class 
    kind extends elter {
      function 
    __construct() {
        
    $this->show();
      }
    }


    $obj = new elter();
    $obj->var 'value';
    $obj->nkind();
    $obj->kind->var .= ' was modified';
    $obj->kind->show(); 
    nun soll 'value' und anschließend 'value was modified' ausgegeben werden.

    zwei möglichkeiten vermisse ich also, bzw. hab nich herausgefunden wies geht.

    zunächst das (natürlich optionale) vererben der aktuellen werte des elternobjektes.
    weiterhin, (prinzipiell - brauch ich grad aber nicht) natürlich selbiges als referenz statt als initialisierungsprozesses. sprich: kind ist bereits initialisiert, elter->var wird verändert, und somit die referenz elter->kind->var

    sinn und zweck der geschichte ist eben das verfeinern gewisser aufgaben:

    in elter werden defaults gesetzt, zunächst von der klasse, anschließend aber vom aufrufenden code!
    sodann werden kindx und kindy (...) initialisiert und je nach aufgabe werden die werte vom aufrufenden code ein zweites mal angepaßt.


    gibt es eine elegante, bestenfalls von php gegebene, lösung hierfür?

    schön wäre sowas wie
    class kind extends current elter {}
    und
    class kind extends reference elter {}

    die möglichkeit elter zu übergeben oder dessen member via get_object_vars in einer schleife abzuarbeiten und so $this des kinds zu überschreiben halte ich für extrem bescheuert (kann ich mir fast schon extends sparen, wären da nicht noch die methoden), sehe aber grad keine bessere lösung.

    tss, schon schlimm, da hat man endlich mal eine aufgabe in der sich oop wirklich als sinnvoll erweisen würde, und dann sowas!

    vielleicht zum besseren verständnis noch angehängt dies:
    PHP-Code:
    class cousin extends elter {
      function 
    __construct() {
        
    $this->show();
      }
    }

    $obj->cousin = new cousin();
    $obj->cousin->show(); 
    soll 'value' ausgeben
    Zuletzt geändert von Ichier; 29.10.2007, 13:24.
    wissen ist macht
    nichts wissen macht nichts

  • #2
    Re: oop class extends vererbung / referenz

    Kennst du __clone()?

    Da mir nicht klar ist, wo im 2. Beispiel das 'value' herkommen soll, gehe ich darauf mal nicht ein.

    Kommentar


    • #3
      clone kenn ich aber das ist ja dann eine kopie des parent kein extending child mit zusätzlichen methoden :/ oder hab ich da was falsch in erinnerung?

      der zweite codeschnipsel wird selbstverständlich an den ersten angehängt ... das cousin->show kann man sich sparen oder den constructor :P oder man hat 2 x 'value' als ausgabe - äh nee, sollte/wollte haben ... whatever. sollte nur zeigen, daß elter->var weiterleben muß, modifiziert.
      wissen ist macht
      nichts wissen macht nichts

      Kommentar


      • #4
        Ich seh zwar noch nicht so denn Sinn aber mit Reflections kannst du sowas erreichen.
        Die Regeln | rtfm | register_globals | strings | SQL-Injections | [COLOR=silver][[/COLOR][COLOR=royalblue]–[/COLOR][COLOR=silver]][/COLOR]

        Kommentar


        • #5
          Reflections : hmmm, wie denn?

          ich kann mit dem begriff zurückentwickeln nicht viel anfangen. :/

          habs mir allerdings nur kurz angesehn; das gefällt mir schonmal gar nicht :
          Um einen Blick in eine Klasse zu werfen, muss man zuerst eine Instanz der Klasse ReflectionClass erzeugen. Man kann danach jede der oben angeführten Methoden der Instanz verwenden.
          sah jetzt für mich aus, als ob ich damit auf die werte des parent zugreifen kann, was ich ja aber durch übergabe oder oder oder eh könnte, dann also ebenso im constructor in einer schleife nach self:: umschreiben müsste. oder hab ich was übersehen das es automatisch oder mittels performantem befehl erledigt.

          ich sehe nicht ganz warum dir der sinn nicht ersichtlich ist
          zunächst klassisch: basisklasse und diverse verfeinerte welche mit zusatzaufgaben -> extends
          dann aber eben das gleiche mit den werten:
          basiswerte aus der basisklasse
          dann basiswerte aus dem aufrufenden code
          und dann für spezielle fälle, eben den extended subclasses, nochmals abweichende werte
          so wie im beispielcode halt

          grundprinzip -> grundaufgabe -> spezialaufgabe

          einfaches realbeispiel? *grübel*
          hm, etwas sinnlos ...also würde so keiner machen mit sql outputmischmasch, und überhaupt... aber ergibt sinn ...najaaa, genaugenommen - in meinem, viel komplexerem, fall ist der sinn gegeben...
          PHP-Code:
          class  elter {
            var 
          $db 'localhost';
            var 
          $table;
            var 
          $select =  array('id');
            var 
          $where;
            var 
          $filename 'export';
            var 
          $encoding 'UTF-8';

            function 
          xml () {
              
          $this->xml = new elter_xml();
            }

            function 
          csv () 
              
          $this->csv = new elter_csv();
            }

            function 
          action() {
              return 
          sqlselect($this->db,$this->table,$this->select,$this->where);
            }

            function 
          send_file() {
              
          //blah
            
          }
          }

          class 
          elter_xml extends elter {
            var 
          $root 'data';
            var 
          $rows 'dataset';
            var 
          $extension 'xml';

            function 
          do_action() {
              
          $this->res generate_xml($this->action(),$this->root,$this->rows,$this->encoding);
            }
          }

          class 
          elter_csv extends elter {
            var 
          $separator ',';
            var 
          $quotes '"';
            var 
          $extension 'csv';

            function 
          do_action() {
              
          $this->res generate_csv($this->action(),$this->separator,$this->quotes,$this->encoding);
            }
          }


          $exp = new elter();
          $exp->filename 'kunden';
          $exp->table 'kundendaten';
          $exp->select = array('kundennummer','name');

          switch (
          $request) {
            case 
          'csv' 
              
          $exp->csv();
              
          $exp->csv->separator ';';
              
          $exp->csv->select[] = 'vorname';
              
          $exp->csv->where = array('flag_exclude_csv'=>0);
              
          $exp->csv->do_action();
              break;
            case 
          'xml15' 
              
          $exp->xml();
              
          $exp->xml->filename .= '_iso8859-15';
              
          $exp->xml->encoding 'ISO-8859-15';
              
          $exp->xml->root 'kdb';
              
          $exp->xml->do_action();
              break;
          }
          $exp->send_file();
          exit; 
          hm, jetzt klarer? ist dasselbe nur ausführlicher


          wenn solch eine funktionalität gegeben wäre von phpseite, so wäre das wesentlich performanter als innerhalb php-script blöd ne schleife abzuarbeiten

          die lösungsmöglichkeit die ich sehe und für bescheuert halte:
          PHP-Code:
          class elter {
            function 
          kind() {
              
          $this->kind = new nkind($this);
            }
          }

          class 
          nkind extends elter {
            function 
          __construct($par) {
              foreach (
          $par as $k=>$v) {
                if(!
          is_object($v)) { $this->$k $v; }
              }
            }


          wenn dus dennoch nicht verstehst, wie würdet ihr denn sonst die aufgabe lösen?


          zu clone fällt mir auch nix ein:
          PHP-Code:
          class elter {
            function 
          kind() {
              
          $this->kind = clone $this;
              
          //wie krieg ich jetzt die extended methoden und member nach kind ?
            
          }

          wissen ist macht
          nichts wissen macht nichts

          Kommentar


          • #6
            Du hast einfach eine komplett falsche Herangehensweise: Statt erst das Elternelement zu erstellen, die Daten abzufragen und dann über das Kindelement die Daten zu verarbeiten solltest du erst überlegen was du willst, dann das Kind erstellen, mit diesem Objekt (über die geerbten Methoden) die Daten holen und dann verarbeiten:
            PHP-Code:
            class data {
                private 
            $_data;
                
                public function 
            fetchData ( ) {
                    
            $this -> _data sql ( ... );
                }    
            }

            class 
            xmlData extends database {
                public function 
            getAsXML ( ) {
                    return 
            getData $this -> _data );
                }
            }

            class 
            cvsData extends database {
                public function 
            getAsCVS ( ) {
                    return 
            getData $this -> _data );
                }
            }

            switch ( 
            $request ) {
                case 
            'cvs':
                    
            $data = new cvsData ( );
                    break;
                case 
            'xml':
                    
            $data = new xmlData ( );
                    break;
            }

            $data -> fetchData ( );
            print_r $data -> getData ( ) ); 
            Ist alles etwas vereinfacht, die Methoden heißen der Einfachheit halber gleich. So macht man OOP - einen Anwendungszweck wo das so nicht geht kann ich mir im Moment nicht vorstellen -> ansonsten musst du dich mal etwas genauer äußern.
            Die Regeln | rtfm | register_globals | strings | SQL-Injections | [COLOR=silver][[/COLOR][COLOR=royalblue]–[/COLOR][COLOR=silver]][/COLOR]

            Kommentar


            • #7
              Du hast einfach eine komplett falsche Herangehensweise
              kann sein
              Statt erst das Elternelement zu erstellen, die Daten abzufragen und dann über das Kindelement die Daten zu verarbeiten solltest du erst überlegen was du willst, dann das Kind erstellen, mit diesem Objekt (über die geerbten Methoden) die Daten holen und dann verarbeiten
              näh, das nützt nich
              (weil der aufrufende code aus verschiedenen quellen generiert wird, da iss nix mit fetch sql und auch nix mit einheitlicher class die das übernehmen könnte; es ist dynamischer code und von daher brauche ich auch diese funktionalität und diese hierachie, dieses vererbungsprinzip)
              So macht man OOP
              man vielleicht
              ansonsten musst du dich mal etwas genauer äußern.
              nagut, dann so:

              ich brauche die funktionalität von
              PHP-Code:
              class elter {
                function 
              kind() {
                  
              $this->kind = new kind($this);
                }
              }

              class 
              kind extends elter {
                function 
              __construct($par) {
                  foreach (
              $par as $k=>$v) {
                    if(!
              is_object($v)) { $this->$k $v; }
                  }
                }

              damit ich folgendes machen kann:
              PHP-Code:
              $elter = new elter();
              $elter->val = array(1,2);
              $elter->kind(); 
              mit dem ergebnis $elter->kind == array (1,2);

              warum ist ja eigentlich egal. spar ich mir jetzt. vereinfachte beispiele sind oben.

              aber so wies schient ist das nicht vorgesehn und man muß sich auf scriptebene damit herumschlagen, *grumpf*.
              es wäre einfach umzusetzen, und auch eingefleischte oopler hätten ihren nutzen darin, dessen bin ich mir sicher, auch wenn es eine weile dauern könnte und umständliche techniken überdacht werden müssten.

              statt erstgenanntem codeschnipsel wäre dies cool:
              PHP-Code:
              class elter {
                function 
              kind() {
                  
              $this->kind = new kind();
                }
              }

              class 
              kind extends current elter {
                
              //
                // wobei fürs automatische vererben vorrausgesetzt würde, daß 
                // a) child innerhalb von parent instanziiert wird
                // oder
                // b) child als sub von elter insanziiert wird
                // oder maunell
                // c) parent übergeben werden muß wie in meinem workaround
                //
                // akzeptabel wäre auch noch eine funktion zum anwenden im constructor
                //
                // alles schneller als auf scriptebene
                //

              wissen ist macht
              nichts wissen macht nichts

              Kommentar


              • #8
                Irgendwie checke ich absolut nicht, was du vor hast...

                Kommentar


                • #9
                  Aber ich weiß, was er tut!!
                  Er beschäftigt min. 2 Foren mit seinem Problem!

                  @Ichier
                  Lesen:
                  http://www.peterkropff.de/site/tutorials/php_oop.htm
                  http://www.knusperleicht.at/index.ph...erung_mit_PHP5
                  http://www2.professionelle-softwaree...erste_auflage/

                  Zu den üblichen OOP Konzepten bzw. Design Pattern ist schon massig geschrieben worden. Google hilft dir weiter.
                  Wir werden alle sterben

                  Kommentar


                  • #10
                    danke combie, allerdings habe ich bisher durchaus zugang zu den handelsüblichen informationen gehabt. abgesehen davon, daß ich php-oop nicht nicht nutze, da mir grundliegendes verständnis fehlt, sondern mir die performance nicht paßt, sind es gute links.

                    performance ist auch das was ich mit diesem post will. (ist vielleicht zu zeiten da gpu schneller sind als cpu, schwer zu verstehen.)

                    daher auch der identische post auf selfphp ...um zu einem ergebnis zu kommen braucht es bei unkonventionellen fragen viele nerds um den heißen brei herum.

                    was ich an funktionalität brauche habe ich oben mittels meines workarounds exakt beschrieben. ich brauche exakt dieses verhalten.

                    falls nicht klar ist was dieser code bewirkt. so läßt sich das zuhause ausprobieren oder nach lektüre der oben genannten links sicher nachvollziehen.

                    was ich suche ist eine php-native methode diese art von vererbung zu bewirken.
                    da ich mir zunächst nicht vorstellen konnte, daß eine deratig praktische funktionalität nicht vorghanden ist, und mich nur für zu müde hielt beim überfliegen der literatur den knackpunkt zu finden, meine posts.

                    und: ja, mir ist bewußt daß ich das prinzip oop ein wenig auf den kopf stelle. nur komischerweise hätte es mittels der von mir erwarteten implementierung eine funktinalität, die besser nicht umzusetzen ist. oder gibt es noch andere möglichkeiten?

                    auf der anderen seite mache ich nichts als 0815-oop. bloß daß ich keine default-werte einer basisklasse vererben möchte sondern die aktuellen eines objektes.

                    vielleicht ist das der punkt der nicht klar ist? es geht um WERTE. dynamisch festgelegt, on the run, jedes mal anders. sie sollen vererbt werden.

                    doch. es ergibt sinn. es ist ziemlich praktisch, sogar.


                    mein heut mittag erdachtes workaround hat übrigens mindestens noch einen fehler, wie ich grad sehe :
                    PHP-Code:
                    class elter {
                      function 
                    kind() {
                        
                    $this->kind = new kind($this);
                      }
                    }

                    class 
                    kind extends elter {
                      function 
                    __construct($par) {
                        foreach (
                    $par as $k=>$v) {
                          if( !
                    is_object($v) && !isset($this->k) ) { $this->$k $v; }
                        }
                      }

                    so und finally zur performance und meiner intention:

                    meine überlegung ist diese:
                    beim erstellen des kind-objektes wird die elternklasse einmal durchlaufen.
                    beim workaround nehme ich mir nun das elternobjekt zur hand und lasse es nochmals durchlaufen um die werte ins kindobjekt zu vererben.
                    das ist unnötig!
                    könnte ich nativ ein objekt vererben, so würde dieses einmal durchlaufen werden und wir sparen uns 50% initialisierungszeit. mehr noch, da ich davon ausgehe, daß der durchlauf auf scriptebene verhältnismäßig länger dauert!

                    nu? alles verstanden? jemand eine bessere lösung?

                    danke, nïkö


                    btw wer ist eigentlich für das forum zuständig? ist ja anstrengend, nach timeout ist der bezug zum thread weg, beim einloggen braucht man 2xtab ...
                    wissen ist macht
                    nichts wissen macht nichts

                    Kommentar


                    • #11
                      nu? alles verstanden?
                      Nöö...
                      Eltern dürfen nix über ihre Kinder wissen!
                      Du verstößt dagegen......
                      Und dabei kann ich dir nicht helfen.

                      Dein Beispiel verstehe ich auch nicht!!
                      Klar, was es tut ja, aber nicht, was du wirklich erreichen möchtest und warum das unbedingt so gemacht werden soll... da gibts bestimmt ganz andere Mittel und Wege!

                      dynamisch festgelegt, on the run, jedes mal anders. sie sollen vererbt werden.
                      Man kann keine dynamischen Werte vererben!
                      Wie auch?
                      Zuletzt geändert von combie; 29.10.2007, 22:20.
                      Wir werden alle sterben

                      Kommentar


                      • #12
                        Fragt sich natürlich warum die Daten dann nicht per Konstruktor übergibts. Das was du machst ist jedenfalls keine Lösung.
                        Die Regeln | rtfm | register_globals | strings | SQL-Injections | [COLOR=silver][[/COLOR][COLOR=royalblue]–[/COLOR][COLOR=silver]][/COLOR]

                        Kommentar


                        • #13
                          Eine Übergabe von Werten in der Vererbung ist natürlich quatsch. Vielleicht ist das Prototypmuster etwas, das du suchst!

                          Kommentar


                          • #14
                            combie, mit dogmatismus kommen wir hier nicht weiter. löblich, daß du die grundlagen beherrschst. aus einem stahlhelm kann man auch suppe essen. war dafür allerdings nicht vorgesehen. ist aber komischerweise effizienter als die hände zu nehmen solange die schüssel und der teller noch nicht erfunden sind. wir wollen hier eine problemlösung finden. code muß sauber, effizient, schlüssig uvm. sein, aber um gottes willen: niemals religiös!

                            btw: es ist technisch egal, praktisch praktischer, wenn ich eine spezifische wrapperklasse baue, die kindobjekte instantiiert, die genau weiß was sie tut, die kindobjekte beherbergt, als es manuell zu machen:
                            $a->b = new c();
                            ist das selbe wie
                            mein o.g.
                            $a->b();
                            wenn b() dann self::b = new c(); ist
                            das wird noch interessanter wenn ich subs gleich im constructor instantiiere... das nur am rande, fuck religion, start to think!
                            Man kann keine dynamischen Werte vererben! Wie auch?
                            indem man vom objekt erben könnte.
                            wie das gehen könnte habe ich zuvor skizziert.
                            einen weg, wie das praktisch umsetzbar ist, habe ich mit meinem o.g. workaround gezeigt.
                            da gibts bestimmt ganz andere Mittel und Wege!
                            natürlich! ich hoffe doch. es gibt immer mehr als eine lösung. oft sogar mehrere gute. deshalb bin ich hier im forum.
                            zeig mir doch bitte einen Weg!
                            ich hab nämlich noch keinen gefunden. deshlab bin ich hier im forum. was bewirkt werden soll ist ja bereits geklärt und anhand des o.g. codes exakt definiert. (... da fehlt noch ein $ bei !isset($this->$k) )

                            ich hab auch noch ein ganz simples praxisbeispiel ausgedacht: settings:
                            system gibt werte vor (basisklasse). - user passt werte an (basisobjekt). - für eine besondere aufgabe gibt es zusätzliche werte und das system überschreibt außerdem ein paar der basiswerte (kindklasse). - der user wiederum paßt sich hierfür diverse werte an, ebenfalls die basiswerte überschreibend (kindobjekt).

                            @ tontechniker : was meinst du mit per konstruktor? das macht das workaround doch; aber ich möchte ja das zweifache durchschleifen der klasse, insbesondere des objektes auf scriptebene, beim instantiieren vermeiden.

                            @ phpdesaster : klingt vielversprechend, auch wenn es nur ein designpattern ist, werd es mir jetzt mal genauer in bezug auf php ansehn und wie ich meine methoden und member erweitern kann.
                            wissen ist macht
                            nichts wissen macht nichts

                            Kommentar


                            • #15
                              Du verwechselst Dogmatismus mit Disziplin!!

                              Du willst dort eine Rückbezüglichkeit einbauen, welche fast nur mit PHP überhaupt möglich ist! Meist muß man Klassen VOR der Verwendung deklarieren. PHP öffnet an ettlichen Ecken und Kanten massig Möglichkeiten für Schweinereien.

                              Deinen (meines bescheidenen Erachtens nach falschen) Weg hast du ja jetzt oft genug beschrieben. Aber was du wirklich erreichen möchtest, ist mir bisher noch lange nicht klar!

                              Ach ja: Nicht jede Kuh sollte auf dem Performace-Altar geopfert werden..

                              von wahsaga:
                              ForenpostingMitPerformancefrageBewertungsfaustregel:
                              Wer Fragen nach der Performance solcher Kinkerlitzchen stellt, der programmiert
                              vermutlich noch nicht mal ansatzweise performant.Andernfalls, wenn er wirklich
                              und zu Recht an einer Applikation arbeiten würde, bei der dieses Quentchen
                              entscheidend ist, sollte er diese Frage gar nicht mehr stellen müssen.
                              -----------------
                              PS:
                              Ich habe mir deinen Post vom 29-10-2007 17:21 noch mal durchgelesen. Wenn ich das richtig verstanden habe, soll dein "elter" verschiedene Klassen erzeugen können, welche verschiedenste Ausgaben tätigen sollen bzw. DB Inhalt in csv,pdf,jpg,xml,html verwandeln.

                              Mein Vorgehen wäre in diesem fall ganz klar!!
                              Als erstes wird ein gemeinsames Interface erzeugt.
                              Würde bei dir ja gar nicht viel brauchen..
                              Eine Funktion action() und eine send_file(), oder?
                              So, und die jeweils benötigte Klasse würde ich mir von einer Implementierung des Factory Design Pattern bereitstellen lassen. Dieses dürfte die sauberste und performanteste Methode sein!!

                              Als Beispiel, könnte ich dir hier auf Wunsch eine rudimentäre DB Klasse zeigen welche von einer Fabrik erzeugt wird.



                              Zuletzt geändert von combie; 31.10.2007, 14:43.
                              Wir werden alle sterben

                              Kommentar

                              Lädt...
                              X