classe d'accès PHP dans une autre classe

Question

J'ai donc deux classes comme celle-ci:

class foo { 
    /* code here */ 
} 
$foo = new foo(); 
class bar { 
    global $foo; 
    public function bar() { 
     echo $foo->something(); 
    } 
} 

Je veux accéder aux méthodes de foo dans toutes les barres de méthodes, sans le déclarer dans chaque méthode bar à l'intérieur, comme celui-ci:

class bar { 
    public function bar() { 
     global $foo; 
     echo $foo->something(); 
    } 
    public function barMethod() { 
     global $foo; 
     echo $foo->somethingElse(); 
    } 
    /* etc */ 
} 

Je ne veux pas l'étendre non plus. J'ai essayé d'utiliser le mot-clé var, mais cela n'a pas semblé fonctionner. Que dois-je faire pour accéder à l'autre classe "foo" à l'intérieur de toutes les méthodes de la barre?

Answer 1

Vous pouvez le faire comme ça aussi:

class bar { 
    private $foo = null; 

    function __construct($foo_instance) { 
     $this->foo = $foo_instance; 
    } 

    public function bar() { 
     echo $this->foo->something(); 
    } 
    public function barMethod() { 
     echo $this->foo->somethingElse(); 
    } 
    /* etc, etc. */ 
} 

Plus tard, vous pouvez faire:

$foo = new foo(); 
$bar = new bar($foo); 

Answer 2

En faire un membre de la barre. Essayez de ne jamais utiliser de globales.

class bar { 
    private $foo; 

    public function __construct($foo) { $this->foo = $foo; } 

    public function barMethod() { 
     echo $this->foo->something(); 
    } 
} 

Answer 3

La réponse courte: Non, il n'y a aucun moyen de mettre en œuvre ce que vous voulez.

Une autre réponse courte: vous travaillez avec des classes de «fausses» manières. Une fois que vous avez sélectionné paradigme orienté objet - oublier le mot clé "global".

La bonne façon de faire ce que vous voulez est de créer une instance de foo en tant que membre de bar et d'utiliser ses méthodes. Ceci est appelé delegation.

Answer 4

Une option consiste à charger automatiquement vos classes. En outre, si vous faites votre classe une classe statique, vous pouvez appeler sans $classname = new classname():

//Autoloader 
spl_autoload_register(function ($class) { 
$classDir = '/_class/'; 
$classExt = '.php'; 
include $_SERVER['DOCUMENT_ROOT'] . $classDir . $class . $classExt; 
}); 

//Your code 
class bar { 
    private static $foo = null; //to store the class instance 

    public function __construct(){ 
     self::$foo = new foo(); //stores an instance of Foo into the class' property 
    } 

    public function bar() { 
     echo self::$foo->something(); 
    } 
} 

Si vous convertissez votre classe (foo) dans une classe statique

//Autoloader 
spl_autoload_register(function ($class) { 
$classDir = '/_class/'; 
$classExt = '.php'; 
include $_SERVER['DOCUMENT_ROOT'] . $classDir . $class . $classExt; 
}); 

//Your code 
    class bar { 
     public function bar() { 
      echo foo::something(); 
     } 
    } 

Answer 5

Et si votre seul objectif est les méthodes elles-mêmes par opposition à l'instance d'une autre classe, vous pouvez utiliser x extends y.

class foo { 
    function fooMethod(){ 
    echo 'i am foo'; 
    } 
} 

class bar extends foo { 
    function barMethod(){ 
    echo 'i am bar'; 
    } 
} 

$instance = new bar; 
$instance->fooMethod();