PHP classe di accesso all'interno di un'altra classe

Question

Così ho due classi come questo:

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

voglio accedere ai metodi di pippo all'interno di tutti i metodi bar, senza dichiararlo in ogni metodo all'interno di bar, come questo:

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

Non voglio estenderlo neanche. Ho provato a utilizzare la parola chiave var, ma non sembra funzionare. Cosa devo fare per accedere all'altra classe "pippo" all'interno di tutti i metodi della barra?

Answer 1

Si potrebbe fare come anche questo:

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

In seguito si potrebbe fare:

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

Answer 2

Farlo membro del bar. Cerca di non usare mai i globali.

class bar { 
    private $foo; 

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

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

Answer 3

La risposta breve: no, non v'è alcun modo per implementare ciò che si desidera.

Un'altra risposta breve: stai lavorando con le classi in modo "sbagliato". Dopo aver selezionato il paradigma Object Oriented, dimentica la parola chiave "globale".

Il modo corretto di fare ciò che si desidera è creare un'istanza di foo come membro di bar e utilizzarne i metodi. Questo è chiamato delegation.

Answer 4

Un'opzione è per caricare automaticamente le classi. Inoltre, se fate la vostra classe una classe statica, si può chiamare senza $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(); 
    } 
} 

Se si converte la classe (foo) in una classe statica

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

E se il vostro obiettivo è solo i metodi stessi in contrasto con l'istanza di un'altra classe, è possibile utilizzare 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();