klassenübergreifend

[TobiaZ]

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.

[BlobBanana]

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 ...

[BlobBanana]

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

[BlobBanana]

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

[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.

[BlobBanana]

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"

[TobiaZ]

das static versteh ich net so ganz.

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

[BlobBanana]

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

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.

[gisu]

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:

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

[namxam]

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

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 )

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

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.

[TobiaZ]

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?

---

[freudenspender]

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

    /**
    * 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

    /**
    * 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

$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 ^^

[TobiaZ]

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?

---

[freudenspender]

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

[TobiaZ]

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