Suggerimento di php che non va d'accordo con le interfacce e le classi astratte?

Question

Penso che sarà molto più facile vedere il problema in un esempio di codice che scrivere la domanda in primo luogo. Ecco il mio codice php:

<?php 

interface AnInterface 
{ 
     public function method(); 
}  

class AClass implements AnInterface 
{ 
     public function method() 
     { 
       echo __METHOD__; 
     } 
}  

abstract class AnAbstractClass 
{ 
     abstract public function method(AnInterface $Object); 
} 

class ConcreteClass extends AnAbstractClass 
{ 
     public function method(AClass $Object) 
     { 
       $Object->method(); 
     } 
} 

$Object1 = new ConcreteClass(); 
$Object2 = new AClass(); 

$Object1->method($Object2); 

Il codice sopra provoca il seguente errore:

Fatal error: Declaration of ConcreteClass::method() must be compatible with that of AnAbstractClass::method()

Il problema è che il PHP non sembra essere riconoscere le firme dei AnAbstractClass :: metodo e ConcreteClass: : metodo come compatibile. Sto facendo qualcosa di sbagliato? Grazie!

Answer 1

php doesn't seem to be recognizing the signatures of AnAbstractClass::method and ConcreteClass::method as compatible.

PHP è corretto, sono non compatibile. Consentendo solo le istanze di AClass (o dei suoi figli) da passare al ConcreteClass::method, si sta rompendo il contratto che AnAbstractClass dispone: Qualsiasi delle sue sottoclassi deve accettare AnInterface come argomento per la sua method().

Se il vostro esempio funzionato, e ho avuto un'altra classe BClass attuazione AnInterface, avremmo una situazione in cui in base al AnAbstractClass, method() dovrebbe accettare le istanze di BClass, mentre secondo ConcreteClass, non dovrebbe.

Modificare la firma per ConcreteClass::method in modo che corrisponda a quella di AnAbstractClass::method.

Answer 2

Non calcola. Abbiamo avuto la stessa discussione di ieri:
Can parameter types be specialized in PHP

tutte le classi derivate devono implementare le firme del metodo in modo identico.

Questo è qualcosa che idealmente dovrebbe essere controllato in fase di esecuzione. Ma in PHP fa il parser. (. Per compensare, PHP non controlla l'accesso attributo private/protetta al momento di analisi, ma lasciate che uno piuttosto saltare in aria in fase di esecuzione)

Se si desidera applicare un tipo più stringenti, vorrei consigliare:

assert(is_a($Object, "AClass")); 

Answer 3

Ecco un esempio che mostra, perché questo non è consentito:

<?php 
class BClass implements AnInterface { } 

function moo(AnAbstractClass $abstract) 
{ 
    $b = new BClass(); 
    $abstract->method($b); 
} 

questo sarebbe un codice valido, ma sarebbe fallire, se si passa un ConcreteClass a MOO, perché il suo metodo di ConcreteClass::method non consente BClass.

E 'complicato, ma è più facile da capire, se vedete un esempio.