La dichiarazione dei metodi dovrebbe essere compatibile con i metodi padre in PHP

Standard rigorosi: la dichiarazione di childClass :: customMethod () dovrebbe essere compatibile con quella di parentClass :: customMethod ()

Quali sono le possibili cause di questo errore in PHP? Dove posso trovare informazioni su cosa significa essere compatibili ?

childClass::customMethod()ha argomenti diversi o un livello di accesso diverso (pubblico / privato / protetto) rispetto a parentClass::customMethod().

Questo messaggio significa che esistono alcune possibili chiamate di metodo che potrebbero non riuscire in fase di esecuzione. Supponi di averlo fatto

class A { public function foo($a = 1) {;}}
class B extends A { public function foo($a) {;}}
function bar(A $a) {$a->foo();}

Il compilatore controlla solo la chiamata $ a-> foo () rispetto ai requisiti di A :: foo () che non richiede parametri. $ a può tuttavia essere un oggetto di classe B che richiede un parametro e quindi la chiamata fallirebbe in fase di esecuzione.

Questo tuttavia non può mai fallire e non fa scattare l'errore

class A { public function foo($a) {;}}
class B extends A { public function foo($a = 1) {;}}
function bar(A $a) {$a->foo();}

Quindi nessun metodo può avere più parametri richiesti del suo metodo genitore.

Lo stesso messaggio viene generato anche quando i suggerimenti sul tipo non corrispondono, ma in questo caso PHP è ancora più restrittivo. Questo dà un errore:

class A { public function foo(StdClass $a) {;}}
class B extends A { public function foo($a) {;}}

come fa questo:

class A { public function foo($a) {;}}
class B extends A { public function foo(StdClass $a) {;}}

Questo sembra più restrittivo di quanto dovrebbe essere e presumo sia dovuto agli interni.

Le differenze di visibilità causano un errore diverso, ma per lo stesso motivo di base. Nessun metodo può essere meno visibile del suo metodo genitore.

se vuoi mantenere la forma OOP senza disattivare alcun errore, puoi anche:

class A
{
    public function foo() {
        ;
    }
}
class B extends A
{
    /*instead of : 
    public function foo($a, $b, $c) {*/
    public function foo() {
        list($a, $b, $c) = func_get_args();
        // ...

    }
}

Solo per espandere questo errore nel contesto di un'interfaccia, se stai scrivendo suggerendo i parametri della tua funzione in questo modo:

interfaccia A

use Bar;

interface A
{
    public function foo(Bar $b);
}

Classe B

class B implements A
{
    public function foo(Bar $b);
}

Se hai dimenticato di includere l' useistruzione nella tua classe di implementazione (Classe B), riceverai anche questo errore anche se i parametri del metodo sono identici.

Ho affrontato questo problema mentre cercavo di estendere una classe esistente da GitHub. Proverò a spiegarmi, prima scrivendo la classe come pensavo che dovrebbe essere, e poi la classe come è adesso.

Quello che ho pensato

namespace mycompany\CutreApi;

use mycompany\CutreApi\ClassOfVendor;

class CutreApi extends \vendor\AwesomeApi\AwesomeApi
{
   public function whatever(): ClassOfVendor
   {
        return new ClassOfVendor();
   }
}

Quello che ho finalmente fatto

namespace mycompany\CutreApi;

use \vendor\AwesomeApi\ClassOfVendor;

class CutreApi extends \vendor\AwesomeApi\AwesomeApi
{
   public function whatever(): ClassOfVendor
   {
        return new \mycompany\CutreApi\ClassOfVendor();
   }
}

Quindi sembra che questo errore venga generato anche quando si utilizza un metodo che restituisce una classe con spazio dei nomi e si tenta di restituire la stessa classe ma con un altro spazio dei nomi. Fortunatamente ho trovato questa soluzione, ma non comprendo appieno i vantaggi di questa funzionalità in php 7.2, per me è normale riscrivere i metodi delle classi esistenti quando ne hai bisogno, inclusa la ridefinizione dei parametri di input e / o anche il comportamento del metodo.

Uno svantaggio del precedente approccio è che gli IDE non sono stati in grado di riconoscere i nuovi metodi implementati in \ mycompany \ CutreApi \ ClassOfVendor (). Quindi, per ora, seguirò questa implementazione.

Attualmente fatto

namespace mycompany\CutreApi;

use mycompany\CutreApi\ClassOfVendor;

class CutreApi extends \vendor\AwesomeApi\AwesomeApi
{
   public function getWhatever(): ClassOfVendor
   {
        return new ClassOfVendor();
   }
}

Quindi, invece di provare a usare il metodo "qualunque", ne ho scritto uno nuovo chiamato "getWwhat". In realtà entrambi stanno facendo lo stesso, restituendo solo una classe, ma con spazi dei nomi diversi come ho descritto prima.

Spero che questo possa aiutare qualcuno.