Declaração de métodos deve ser compatível com métodos pais em PHP

Padrões estritos: a declaração de childClass :: customMethod () deve ser compatível com a de parentClass :: customMethod ()

Quais são as possíveis causas desse erro no PHP? Onde posso encontrar informações sobre o que significa ser compatível ?

childClass::customMethod()tem argumentos diferentes ou um nível de acesso diferente (público / privado / protegido) do que parentClass::customMethod().

Esta mensagem significa que existem certas chamadas de método possíveis que podem falhar em tempo de execução. Suponha que você tenha

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

O compilador apenas verifica a chamada $ a-> foo () em relação aos requisitos de A :: foo () que não requer parâmetros. $ a pode, entretanto, ser um objeto da classe B que requer um parâmetro e, portanto, a chamada falhará em tempo de execução.

No entanto, isso nunca pode falhar e não aciona o erro

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

Portanto, nenhum método pode ter mais parâmetros necessários do que seu método pai.

A mesma mensagem também é gerada quando as dicas de tipo não correspondem, mas neste caso o PHP é ainda mais restritivo. Isso dá um erro:

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

assim como isso:

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

Isso parece mais restritivo do que precisa ser e suponho que seja devido aos internos.

As diferenças de visibilidade causam um erro diferente, mas pelo mesmo motivo básico. Nenhum método pode ser menos visível do que seu método pai.

se quiser manter o formulário OOP sem desativar nenhum erro, você também pode:

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

    }
}

Apenas para expandir esse erro no contexto de uma interface, se você digitar hinting seus parâmetros de função assim:

interface A

use Bar;

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

Classe B

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

Se você esqueceu de incluir a useinstrução em sua classe de implementação (Classe B), você também receberá esse erro, embora os parâmetros do método sejam idênticos.

Enfrentei esse problema ao tentar estender uma classe existente do GitHub. Vou tentar me explicar, primeiro escrevendo a aula como pensei que deveria ser e depois a aula como está agora.

O que eu pensei

namespace mycompany\CutreApi;

use mycompany\CutreApi\ClassOfVendor;

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

O que eu finalmente fiz

namespace mycompany\CutreApi;

use \vendor\AwesomeApi\ClassOfVendor;

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

Portanto, parece que esse erro também surge quando você está usando um método que retorna uma classe com namespace e tenta retornar a mesma classe, mas com outro namespace. Felizmente eu encontrei essa solução, mas não entendo totalmente o benefício desse recurso no php 7.2, para mim é normal reescrever métodos de classe existentes conforme necessário, incluindo a redefinição de parâmetros de entrada e / ou até mesmo o comportamento do método.

Uma desvantagem da abordagem anterior é que os IDEs não podiam reconhecer os novos métodos implementados em \ mycompany \ CutreApi \ ClassOfVendor (). Então, por enquanto, irei com essa implementação.

Atualmente concluído

namespace mycompany\CutreApi;

use mycompany\CutreApi\ClassOfVendor;

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

Então, em vez de tentar usar o método "qualquer coisa", escrevi um novo chamado "getWhatever". Na verdade, os dois estão fazendo o mesmo, apenas retornando uma classe, mas com namespaces diferentes, conforme descrevi antes.

Espero que isso possa ajudar alguém.