Die Deklaration der Methoden sollte mit den übergeordneten Methoden in PHP kompatibel sein

Strenge Standards: Die Deklaration von childClass :: customMethod () sollte mit der von parentClass :: customMethod () kompatibel sein.

Was sind mögliche Ursachen für diesen Fehler in PHP? Wo finde ich Informationen darüber, was es bedeutet, kompatibel zu sein ?

childClass::customMethod()hat andere Argumente oder eine andere Zugriffsebene (öffentlich / privat / geschützt) als parentClass::customMethod().

Diese Nachricht bedeutet, dass es bestimmte mögliche Methodenaufrufe gibt, die zur Laufzeit fehlschlagen können. Angenommen, Sie haben

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

Der Compiler vergleicht den Aufruf $ a-> foo () nur mit den Anforderungen von A :: foo (), für die keine Parameter erforderlich sind. $ a kann jedoch ein Objekt der Klasse B sein, für das ein Parameter erforderlich ist, sodass der Aufruf zur Laufzeit fehlschlagen würde.

Dies kann jedoch niemals fehlschlagen und löst den Fehler nicht aus

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

Daher verfügt möglicherweise keine Methode über mehr erforderliche Parameter als die übergeordnete Methode.

Die gleiche Nachricht wird auch generiert, wenn Typhinweise nicht übereinstimmen, aber in diesem Fall ist PHP noch restriktiver. Dies gibt einen Fehler:

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

wie das:

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

Das scheint restriktiver zu sein, als es sein muss, und ich gehe davon aus, dass dies auf Interna zurückzuführen ist.

Sichtbarkeitsunterschiede verursachen einen anderen Fehler, jedoch aus demselben Grund. Keine Methode kann weniger sichtbar sein als die übergeordnete Methode.

Wenn Sie das OOP-Formular beibehalten möchten, ohne einen Fehler auszuschalten, können Sie außerdem:

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();
        // ...

    }
}

Nur um diesen Fehler im Kontext einer Schnittstelle zu erweitern, wenn Sie Ihre Funktionsparameter wie folgt angeben:

Schnittstelle A.

use Bar;

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

Klasse b

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

Wenn Sie vergessen haben, die useAnweisung in Ihre implementierende Klasse (Klasse B) aufzunehmen, wird dieser Fehler auch angezeigt, obwohl die Methodenparameter identisch sind.

Ich war mit diesem Problem konfrontiert, als ich versuchte, eine vorhandene Klasse von GitHub aus zu erweitern. Ich werde versuchen, mich selbst zu erklären, indem ich zuerst die Klasse so schreibe, wie ich es mir vorgestellt habe, und dann die Klasse so, wie sie jetzt ist.

Was ich aber

namespace mycompany\CutreApi;

use mycompany\CutreApi\ClassOfVendor;

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

Was ich endlich getan habe

namespace mycompany\CutreApi;

use \vendor\AwesomeApi\ClassOfVendor;

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

Es scheint also, dass dieser Fehler auch auftritt, wenn Sie eine Methode verwenden, die eine Klasse mit Namespace zurückgibt, und Sie versuchen, dieselbe Klasse mit einem anderen Namespace zurückzugeben. Glücklicherweise habe ich diese Lösung gefunden, aber ich verstehe den Nutzen dieser Funktion in PHP 7.2 nicht vollständig. Für mich ist es normal, vorhandene Klassenmethoden nach Bedarf neu zu schreiben, einschließlich der Neudefinition von Eingabeparametern und / oder sogar des Verhaltens der Methode.

Ein Nachteil des vorherigen Ansatzes ist, dass IDEs die neuen Methoden, die in \ mycompany \ CutreApi \ ClassOfVendor () implementiert sind, nicht erkennen konnten. Daher werde ich vorerst mit dieser Implementierung fortfahren.

Derzeit fertig

namespace mycompany\CutreApi;

use mycompany\CutreApi\ClassOfVendor;

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

Anstatt zu versuchen, die "was auch immer" -Methode zu verwenden, habe ich eine neue mit dem Namen "getWhatever" geschrieben. Tatsächlich machen beide dasselbe und geben nur eine Klasse zurück, aber mit unterschiedlichen Namespaces, wie ich zuvor beschrieben habe.

Hoffe das kann jemandem helfen.