Qual è l'equivalente delle funzioni virtuali di C++ in PHP?

Question

È abstract function xxx?

Ho appena effettuato un test che sembra indicare anche un metodo privato virtuale?

class a { 
private function test() 
{ 
    echo 1; 
} 
} 

class b extends a { 
private function test() 
{ 
    echo 2; 
} 
public function call() 
{ 
    $this->test(); 
} 
} 

$instance = new b; 
$instance->call(); 

L'uscita è 2

Answer 1

In PHP tutte le funzioni private nessuno sono virtuali quindi non c'è alcun bisogno di loro dichiarare esplicitamente come virtuale.

Dichiarare una funzione membro come abstract significa semplicemente che la classe base non può fornire un'implementazione ma tutte le classi derivate dovrebbero. Definire il metodo come astratto è lo stesso di fare il seguente in C++

virtual void foo() = 0; 

che significa semplicemente che le classi derivanti devono implementare foo();

EDIT: Riguardo la domanda a cura

b::call() non può accedere a::test(). Per questo motivo quando si chiamano funzioni private verrà chiamato solo quello della classe da cui è stato chiamato.

EDIT: quanto riguarda il commento:

(da Wikipieda)

Nella programmazione orientata agli oggetti, una funzione virtuale o metodo virtuale è una funzione o metodo cui comportamento può essere ignorato all'interno una classe ereditante da una funzione con la stessa firma.

A causa dell'idea di affermare esplicitamente ciò che si paga in C++, è necessario dichiarare le funzioni come virtuali per consentire alle classi derivate di sovrascrivere una funzione.

class Foo{ 
public: 
    void baz(){ 
     std::cout << "Foo"; 
    } 
}; 
class Bar : public Foo{ 
public: 
    void baz(){ 
     std::cout << "Bar"; 
    } 
}; 

int main(){ 
    Foo* f = new Bar(); 
    f->baz(); //baz is not virtual in Foo, so the output is Foo 
} 

Change baz essere virtuale

class Foo{ 
public: 
    virtual void baz(){ 
     std::cout << "Foo"; 
    } 
}; 
//Same Bar declaration 

int main(){ 
    Foo* f = new Bar(); 
    f->baz(); //baz is virtual in Foo, so the output is Bar as it will call the derived function 
} 

nota, se la variabile f nell'esempio precedente sia di tipo Bar* o Bar non sarebbe importa se Foo::baz() era virtuale o non come il tipo previsto è noto (il programmatore lo ha fornito esplicitamente)

Answer 2

L'esempio non ha mostrato un modello di specializzazione tipico in cui b non ha bisogno di conoscere i dettagli di implementazione di call() ma può specificare ify come deve essere fatto test(). E restituisce lo 1 sfortunatamente. Tuttavia, dichiarando la funzione protetta anziché privata, funzionerà come previsto.

class a { 
    protected function test() 
    { 
     echo 1; 
    } 
    public function call() { 
     $this->test(); 
    } 
} 

class b extends a { 
    protected function test() 
    { 
     echo 2; 
    } 
} 

$instance = new b(); 
$instance->call(); 

Answer 3

utilizzo parola chiave static (PHP 5.4) non $ this-> meth() ma statica :: meth()