klassenübergreifend

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

  • klassenübergreifend

    Ganz einfache Frage:

    Ich habe zwei klassen.

    jetzt möchte ich mit der Klasse demo auf eine Methode der klasse test zugreifen. Dies geht aber nur, wenn ich das Objekt test an die Demo übergebe.

    Kann man das nicht irgendwie umgehen. meine da gibts was mit extends. komm da aber im moment nicht so ganz hinter.

    Noch mal kurz und Knapp: Ziel ist es, dass demo die methoden von test mitbenutzen kann.

  • #2
    Gibts in PHP nicht sowas wie "static" ? Dann koennte man einfach mit KLassenname.Methodenname() die Methode aufrufen ...

    Aber kenn mich nicht mit OOP in PHP aus ...

    In Java wuerd man halt static vor der Methode schreiben ...

    Kommentar


    • #3
      Achso ... mit extends erbt man von der anderen Klasse ...

      also: class demo extends test

      nun muesste man in demo zugriff auf die Methoden von test haben

      Kommentar


      • #4
        So mal eben geguckt nach static in PHP:

        1 static
        Manchmal ist es nötig, eine Methode einer Klasse aufzurufen, ohne ein Objekt derselben erzeugt zu haben. In diesem Fall kann man einen sogenannten static-Aufruf machen. Zu beachten ist dabei, daß eine so aufgerufene Klassenmethode nirgends auf die Attribute der Klasse, in der sie sich befindet, zugreifen darf, da diese ja nur im Kontext einer Instanz (Objekt) vorhanden sind. Lokale und globale Variablen dürfen dagegen natürlich benutzt werden.
        Ein primitves Beispiel:


        class Auto {
        ...
        function Erfinder() {
        return "Etienne Lenoir, Carl Benz";
        }
        ...
        }
        echo Auto::Erfinder();

        http://ffm.junetz.de/members/reeg/DS...00000000000000

        Kommentar


        • #5
          was mich nur n bisschen ankotzt, ist dass ich mit extends nur eine andere klasse benutzen kann. wenn ich die dritte hab, dann verliert er die eigenschaften der ersten wieder.

          Kommentar


          • #6
            Original geschrieben von TobiaZ
            was mich nur n bisschen ankotzt, ist dass ich mit extends nur eine andere klasse benutzen kann. wenn ich die dritte hab, dann verliert er die eigenschaften der ersten wieder.
            siehe mein Post ueber "static"

            Kommentar


            • #7
              das static versteh ich net so ganz.

              aber ich hab herausgefunden, dass ich einfach ein neues objekt erstellen kann. meinste das kann man machen.

              Kommentar


              • #8
                Ein neues Objekt kann man natuerlich erstellen ... die Frage ist nur wie sinnig das ist. Das erzeugen von Objekten kostet sicherlich mehr Ressourcen als ein static Aufruf.

                Vielleicht hilft dir dieses Beispiel ja:

                PHP-Code:
                <?PHP

                class Muhkuh {

                    function 
                static_text($string) {
                        return 
                "Bla ".$string;
                    }
                }

                echo 
                MuhKuh::static_text("Blub");
                ?>
                Hier wurde also eine Methode der Klasse Muhkuh aufgerufen OHNE ein Objekt von ihr erzeugt zu haben ... das nennt man statischen Aufruf.

                Kommentar


                • #9
                  Vor dem Problem stand ich auch mal ich hab es so gelöst:

                  Man erstellt aus innerhalb der aktuell genutzen Klasse eine Instanz Referenz der anderen Klasse.

                  Beispiel mit einer DB und einer User Class:

                  PHP-Code:
                  class User
                  {

                      var 
                  $OtherClass;

                      function 
                  User ( )
                      {
                           
                  // Die User Class ruft die DB Class auf
                           
                  include ( "classDB.php" );
                          
                           
                  // Dann wird die DB Class Instanziert und der $OtherClass zugewiesen
                           
                  $this->OtherClass  =  new $classDB;   // Die DB Klasse wird mit classDB konstruiert
                      
                  }

                      function 
                  CheckName ( ..... )
                      {
                            ....
                            
                  // Jetzt greifen wir intern auf die DB Klasse zu und starten einen DB Connect
                            
                  $this->OtherClass->DB_Connect
                            
                  .....
                      }

                  So hab ich das gemacht und funktioniert auch, aber bei OOP bin ich noch blutiger Anfänger muss das mit Static auch mal probieren.

                  Gruß
                  Gisu

                  Kommentar


                  • #10
                    juhu mein lieblingsthema
                    setze mich gerade intensivst damit auseinander.

                    @tobiaz: das stimmt so nicht ganz. man kann durchaus über mehrere ebenen beerben. zumindest klappt es bei mir noch recht gut.

                    @all: es gibt veschiedene methoden.

                    1.) wie hier schon beschrieben mit statics
                    PHP-Code:
                    class MyClass
                    {
                        
                    // constructor
                        
                    function MyClass()
                        {
                        
                        }
                        
                        function 
                    doOutput()
                        {
                            echo 
                    "success";
                        }
                    }

                    class 
                    MySecond
                    {
                        function 
                    MySecond()
                        {
                            
                        }
                        
                        function 
                    myTest()
                        {
                            
                    MyClass::doOutput();
                        }

                    2.) übergabe eines referenzparameters (oder kopie eines objektes. empfehle ich aber nicht, denn wenn sich dann am orginal was öändert die kopie es nicht mitbekommt )
                    PHP-Code:
                    class MyClass
                    {
                        
                    // constructor
                        
                    function MyClass()
                        {
                        
                        }
                        
                        function 
                    doOutput()
                        {
                            echo 
                    "success";
                        }
                    }

                    class 
                    MySecond
                    {
                        
                    // private
                        
                    var $_myObj;
                        
                        function 
                    MySecond(&myObj)
                        {
                             
                    $this->_myObj =& $myObj;
                        }
                        
                        function 
                    myTest()
                        {
                            if(
                    is_object($this->_myObj)
                            {
                                
                    $this->_myObj->doOutput();
                                return 
                    true;
                            }
                            else
                            {
                                return 
                    false;
                            }
                        }
                    }

                    $x = new MyClass();
                    $y = new MySecond(&$x);
                    $y->myTest(); 
                    alternativ lässt sich das auch mit jeder anderen funktion machen, also nicht nur dem constructor. dann aber aufpassen, daß diese auch aufgerufen wurde bevor der erste zugriff auf $myObj kommt. hab hier beispielhaft nen prüfroutine dafür implementiert.

                    3.) aufruf einer globalen variable
                    PHP-Code:
                    class MyClass
                    {
                        
                    // constructor
                        
                    function MyClass()
                        {
                        
                        }
                        
                        function 
                    doOutput()
                        {
                            echo 
                    "success";
                        }
                    }

                    class 
                    MySecond
                    {
                        
                    // private
                        
                    var $_myObj;
                        
                        function 
                    MySecond(&myObj)
                        {
                             
                    $this->_myObj =& $myObj;
                        }
                        
                        function 
                    myTest()
                        {
                            global 
                    $x;
                            
                            if(
                    is_object($x)
                            {
                                
                    $x->doOutput();
                                return 
                    true;
                            }
                            else
                            {
                                return 
                    false;
                            }
                        }
                    }

                    $x = new MyClass();
                    $y = new MySecond();
                    $y->myTest(); 
                    in diesem beispiel kann ich irgendwo ausserhalb eine instanz eines objektes erstellt haben. verhält sich so wie jede andere globale variable.



                    so, ich glaube das wars. gibt sicher noch mehr möglichkeiten. aber das sind die mir geläufigen. hoffe, ich konnte helfen.
                    Zuletzt geändert von namxam; 25.05.2003, 00:52.

                    Kommentar


                    • #11
                      vielen dank euch allen, das sieht schonmal sehr vielversprechend aus.

                      Mein Ziel ist eigentlich ziemlich ähnlich, wie das von Gisu. Möchte meine seite mit nem ordentlichen usermanagement verwalten, und in dem management auch auf andere klassen zugreifen. also userdaten aus db.

                      im zweifelsfall kann man das ja auch nocht mit extends machen. nur überlege ich, ob das ganze mal erweitert werden könnte. und wenn ich im einfachsten fall noch ne gästebuchklasse schreibe, dann sollte die auch auf db und usermanagement (z.B. um adminlink anzuzeigen) zugreifen können.

                      wie es aussieht, wäre das also dann ein klarer fall für static, oder? Bin im moment noch alles theoretisch (test/demo) am testen, deswegen kann ich zur performance leider wenig sagen. wäre ich eurer meinung also mit static auf dem richtigen weg?

                      EDIT:
                      Hmm, bei der ::-Methode habe ich leider das Problem, dass der Konstruktor ja nicht mitbenutzt wird. Für eine DB-Klasse wäre also eine Initialisierung von nöten denke ich, oder?
                      Zuletzt geändert von TobiaZ; 25.05.2003, 15:36.

                      Kommentar


                      • #12
                        ich arbeite gerade an einem framework und habe mich deshalb ebenfalls damit ein wenig auseinander gesetzt, dabei ist dies heraus gekommen
                        die idee stammt von http://at2.php.net/manual/de/ref.objaggregation.php

                        die Object-Handler-Klasse:
                        PHP-Code:
                        <?php

                            
                        /**
                            * filename:            ObjectHandler.class.php
                            * created:                24.05.03
                            * last change:        25.05.03
                            * author:                Michael Dobretsberger <m.dobretsberger@xetrill.com>
                            * copyright:            Michael Dobretsberger
                            * 
                            * TODO:                get parameter delivery working fine (without a warning)
                            */

                            
                        if(!defined('_C_OBJECTHANDLER'))
                            {

                                
                        define('_C_OBJECTHANDLER'true);

                                class 
                        ObjectHandler
                                
                        {

                                    function 
                        returnObject($sNameOfClass$mParams NULL)
                                    {
                                        if(!
                        is_null($mParams))
                                            return new 
                        $sNameOfClass($mParams);
                                        return new 
                        $sNameOfClass;
                                    } 
                        // end of ()

                                
                        // end of class

                            
                        // end if

                        ?>
                        und die Core-Klasse
                        PHP-Code:
                        <?php

                            
                        /**
                            * filename:            Core.class.php
                            * require:                ObjectHandler.class.php
                            * created:                24.05.03
                            * last change:        25.05.03
                            * author:                Michael Dobretsberger <m.dobretsberger@xetrill.com>
                            * copyright:            Michael Dobretsberger
                            * 
                            * TODO:                get parameter delivery working fine (without a warning)
                            */

                            
                        error_reporting(E_ALL);

                            if(!
                        defined('_C_CORE'))
                            {

                                
                        define('_C_CORE'true);

                                if(!
                        defined('_FRM_ROOTDIR'))
                                    include_once(
                        './../Config.inc.php');
                                if(!
                        defined('_C_OBJECTHANDLER'))
                                    include_once(
                        _FRM_ROOTDIR '/Core/ObjectHandler.class.php');
                                include_once(
                        _FRM_ROOTDIR '/Core/ErrorHandler.class.php');

                                class 
                        Core extends ObjectHandler
                                
                        {

                                    var 
                        $aObjects;

                                    function 
                        Core()
                                    {
                                        
                        $this->newObject('oError''ErrorHandler');
                                        return;
                                    } 
                        // end of Core()

                                    
                        function newObject($sNameOfObject$sNameOfClass$mParams NULL)
                                    {
                                        if(!
                        is_null($mParams))
                                            
                        $this->$sNameOfObject parent::returnObject($sNameOfClass$mParams);
                                        
                        $this->$sNameOfObject parent::returnObject($sNameOfClass);
                                        if(!isset(
                        $this->$sNameOfObject) | !is_object($this->$sNameOfObject))
                                            return 
                        false;
                                        
                        $this->aObjects[] = $sNameOfObject;
                                        return 
                        false;
                                    } 
                        // end of newObject()

                                    
                        function loadNewObject($sNameOfClassFile$sNameOfObject$sNameOfClass$mParams NULL)
                                    {
                                        if(!include_once(
                        $sNameOfClassFile))
                                            return 
                        false;
                                        return 
                        $this->newObject($sNameOfObject$sNameOfClass$mParams);
                                    } 
                        // end of loadNewObject()

                                    
                        function clearByObject($sNameOfObject)
                                    {
                                        
                        $nKey array_search($sNameOfObject$this->aObjects);
                                        if(
                        is_numeric($nKey))
                                            unset(
                        $this->aObjects[$nKey]);
                                        if(isset(
                        $this->$sNameOfObject))
                                            unset(
                        $this->$sNameOfObject);
                                        if(!isset(
                        $this->aObjects[$nKey]) & !isset($this->$sNameOfObject))
                                            return 
                        true;
                                        return 
                        false;
                                    } 
                        // end of clearByObject()

                                    
                        function getObjects()
                                    {
                                        return 
                        $this->aObjects;
                                    } 
                        // end of getObjects()

                                
                        // end of class

                            
                        // end if
                        PHP-Code:
                        $oCore = new Core();
                        $oCore->loadNewObject('pfad/zur/klasse''oFoo''FooClass');
                        // jetzt $oCore->oFoo zur verfügung stehen 
                        mit ein bisschen anpassung lässt es sich sicher gut nutzen

                        naja vielleicht hilfts dir ja ^^

                        Kommentar


                        • #13
                          danke @freudenspender. Kannst du das vielleicht noch n bisschen erlläutern?

                          EDIT:
                          @all: was haltet ihr davon, wenn ich die zweite klasse (also zb. DB_klasse) als Referenz in die erste hole?
                          Zuletzt geändert von TobiaZ; 25.05.2003, 16:18.

                          Kommentar


                          • #14
                            die ObjectHandler klasse übergibt einfach nur objekte
                            die Core klasse speichert diese.
                            von ihr aus kann auf die methoden/variablen zu gegriffen werden wie gewohnt (naja fast)
                            $oCore->neuesObjekt->neueMethode();
                            zusätzlich weiss die Core klasse immer welche objekte sie besitzt (getObjets()), und es können objekte einfach gelöscht werden (clearByObject())

                            somit (kann) man eine 'ultra-klasse' erzeugen
                            und das finde ich einfacher als einen extends-baum zu erstellen

                            Kommentar


                            • #15
                              soll also heißen, ich kann von in(!!!) meiner einen klasse dann auch auf funktionen einer anderen klasse zugreifen?

                              Kommentar

                              Lädt...
                              X