Come chiamare la funzione genitore dall'istanza di child?

Question

Ho modello

BaseUser.class.php 
User.class.php 
UserTable.class.php 

In utente Classe sono stato ignorare la funzione di eliminazione

class User extends BaseUser { 
    function delete(){ 
    } 
} 

Ora, se voglio chiamare genitore funzione di cancellazione .... come?

Esempio

$user = new User(); 
$user->delete(); // will call the overridden delete 
$user-> ?? ;  // want to call parent delete 

Answer 1

Tecnicamente questo non è possibile dal "fuori" (l'interfaccia pubblica) per una buona ragione.

Se avete capito perché (altrimenti leggere qui di seguito), e in realtà sa quello che fai, non v'è alcun motivo per in realtà non offrono la funzionalità:

class User extends BaseUser { 
    ... 
    function parentDelete(){ 
     parent::delete(); 
    } 
    ... 
} 

user = new User(); 
$user->delete(); // will call the overridden delete 
$user->parentDelete();  // want to call parent delete 

Tuttavia se mai fare questo, si dovrebbe sappi che hai in qualche modo abusato dell'eredità. Questa deve essere una situazione eccezionale, dal momento che non riesco a immaginare nessuna situazione in cui sia effettivamente necessario.

Quindi prova a formulare il motivo per cui hai bisogno di quella funzionalità in modo da darti suggerimenti migliori.

Why is that bad?

Per un motivo molto semplice: Nel software non è necessario sapere che $user ha un genitore o no. Questo è un dettaglio di cui non dovresti preoccuparti.

Ciò consente di sostituire qualsiasi oggetto utente presente nel software con un childobject dell'utente in seguito. Questo è importante in quanto si desidera modificare il software nel tempo.

Se si rende la parte dei dettagli interni dell'interfaccia pubblica si sta rubando la possibilità di mantenere le cose flessibili. Non essere flessibili è davvero una brutta situazione.

Answer 2

magari provare questo

parent::delete(); 

Answer 3

Penso che si sta cercando per le funzioni PHP parent:

<?php 
class A { 
    function example() { 
    echo "I am A::example() and provide basic functionality.<br />\n"; 
    } 
} 

class B extends A { 
    function example() { 
    echo "I am B::example() and provide additional functionality.<br />\n"; 
    parent::example(); 
    } 
} 

$b = new B; 

// This will call B::example(), which will in turn call A::example(). 
$b->example(); 
?> 

Se la classe non ha un funzione chiamata getMyFunction() che chiama $b->getMyFuction() chiamerà la funzione genitore. Se lo fa, chiamerà la funzione figlio, a meno che la funzione figlio non chiami la funzione prent.

Answer 4

Perché è necessario estendere delete se è necessario chiamare il genitore una volta?

Perché non creare un'eliminazione personalizzata?

come:

public function customDelete() 
{ 
    parent::delete(); 

    // do extends delete here 
} 

Quindi è possibile eliminare un oggetto utilizzando ->customDelete() e si può anche chiamare il metodo delete dal genitore in quanto non è stato l'override del metodo delete():

$user = new User(); 
$user->customDelete(); // will call the overridden delete 
$user->delete(); // will call the parent (since you didn't override it) 

E se hai davvero devi sostituire la funzione delete(), puoi comunque creare un tipo di eliminazione padre:

public function parentDelete() 
{ 
    return parent::delete(); 
} 

Poi:

$user = new User(); 
$user->delete(); // will call the overridden delete 
$user->parentDelete(); // will call the method that only call the parent 

Answer 5

ho trovato this thread su codingforums. Quello che dice (e io tendo ad essere d'accordo con loro) è che se hai una funzione/metodo sovrascritto in una classe figlia, un'istanza di quell'oggetto chiamerà SEMPRE il metodo figlio.

La parola chiave parent è simile a $this o self e può essere chiamata solo all'interno della classe stessa.

Se si desidera un oggetto figlio per essere in grado di chiamare il metodo genitore, basta creare un altro metodo

function parentExample() { 
    parent::example(); 
} 

che richiama solo il metodo genitore.