Come chiamare il metodo grandparent senza ottenere l'errore E_STRICT?

Question

A volte ho bisogno di eseguire il metodo grandparent (cioè bypassare il metodo genitore), so che questo è odore di codice, ma a volte non riesco a cambiare le altre classi (framework, librerie, ecc.).

In PHP possiamo farlo con qualcosa di simile:

call_user_func(array(get_parent_class(get_parent_class($childObject)), 'grandParentMethod')); 

Il problema è che se si dispone di errori E_STRICT attivato si otterrà un errore del tipo:

norme severe: metodo non statico GrandParent :: grandParentMethod() non dovrebbe essere chiamato staticamente in ...

Ho trovato solo una soluzione per questo (senza rimuovere E_STRICT), ed è solo aggiungendo il @ a s aggiustare l'errore.

Ma questo è davvero brutto, qualcuno conosce una soluzione migliore?

Grazie! PS: Non riesco a un'istanza di un nuovo oggetto del tipo:

$grandparent = get_parent_class(get_parent_class($son)); 
$gp= new $grandparent; 
$gp->grandParentMethod 

perché ho bisogno di chiamare il mio metodo nonni nel contesto di $ figlio.

Answer 1

È possibile utilizzare ReflectionMethod->invoke()

Esempio:

<?php 
class Grandpa { 
    protected $age = 'very old'; 
    public function sayMyAge() { 
     return 'sayMyAge() in Grandpa should be very old. ' . 
        'My age is: ' . $this->age; 
    } 
} 

class Pa extends Grandpa { 
    protected $age = 'less old'; 
    public function sayMyAge() { 
     return 'sayMyAge() in Pa should be less old. ' . 
        'My age is: ' . $this->age; 
    } 
} 

class Son extends Pa { 
    protected $age = 'younger'; 
    public function sayMyAge() { 
     return 'sayMyAge() in Son should be younger. ' . 
        'My age is: ' . $this->age; 
    } 
} 

$son = new Son(); 
$reflectionMethod = new ReflectionMethod(get_parent_class(get_parent_class($son)), 
             'sayMyAge'); 
echo $reflectionMethod->invoke($son); 
// returns: 
// sayMyAge() in Grandpa should be very old. My age is: younger 

Nota: Il metodo richiamato deve essere pubblico.

Answer 2

È possibile utilizzare un metodo interno separato (ad esempio _doStuff per integrare doStuff) e chiamarlo direttamente dal nipotino, tramite il genitore.

// Base class that everything inherits 
class Grandpa { 
    protected function _doStuff() { 
     // grandpa's logic 
     echo 'grandpa '; 
    } 

    public function doStuff() { 
     $this->_doStuff(); 
    } 

} 

class Papa extends Grandpa { 
    public function doStuff() { 
     parent::doStuff(); 
     echo 'papa '; 
    } 
} 

class Kiddo extends Papa { 
    public function doStuff() { 
     // Calls _doStuff instead of doStuff 
     parent::_doStuff(); 
     echo 'kiddo'; 
    } 
} 

$person = new Grandpa(); 
$person->doStuff(); 
echo "\n"; 
$person = new Papa(); 
$person->doStuff(); 
echo "\n"; 
$person = new Kiddo(); 
$person->doStuff(); 

mostra

grandpa 
grandpa papa 
grandpa kiddo 

Answer 3

è possibile chiamare i nonni direttamente per nome (senza alcun call_user_func vincolante).

class Base { 
    protected function getFoo() { 
     return 'Base'; 
    } 
} 

class Child extends Base { 
    protected function getFoo() { 
     return parent::getFoo() . ' Child'; 
    } 
} 

class Grandchild extends Child { 
    protected function getFoo() { 
     return Base::getFoo() . ' Grandchild'; 
    } 
} 

La chiamata Base::getFoo può apparire come una chiamata statica (a causa della sintassi colon ::), ma non lo è. Proprio come parent:: non è statico, neanche. La chiamata di un metodo dalla catena di ereditarietà all'interno di una classe associerà correttamente il valore $this, invocandolo come metodo normale, rispettando le regole di visibilità (ad esempio protetto) e non è una violazione di alcun tipo. All'inizio può sembrare un po 'imbarazzante, ma questo è il modo di farlo in PHP.