2010-05-18 15 views
5

di recente ho esaminato il concetto di ereditarietà.Ereditarietà in Java

Come tutti sappiamo, in ereditarietà, gli oggetti superclass vengono creati/inizializzati prima degli oggetti subclass. Quindi, se creiamo un oggetto di subclass, conterrà tutte le informazioni della superclasse.

Ma a un certo punto mi sono bloccato.

I metodi superclasse e sottoclasse sono presenti su stack di chiamata separati? Se è così, c'è qualche specific reason per lo stesso? Se non è così, perché non appaiono sullo stesso stack di chiamate?

E.g.

// Superclass 
class A { 
    void play1() { 
     // .... 
    } 
} 

// Subclass 
class B extends A { 
    void play2() { 
     //..... 
    } 
} 

poi fa i suddetti 2 metodi cioè play1() e play2() appaiono sullo stack di chiamate separata?

Grazie.

+0

Avete qualche ragione per pensare che * potrebbero * essere su pile diverse? Dato che c'è un preciso bisogno che la superclasse init abbia completamente terminato prima della sottoclasse init, è seriale comunque, no? – CPerkins

risposta

2

Non esiste necessariamente alcuna relazione tra uno stack di chiamate e l'ereditarietà. In realtà spesso non c'è. Se un metodo di una superclasse è sovrascritto in un figlio, allora è il metodo del bambino che viene chiamato - il metodo superclasse non viene eseguito affatto, a meno che non ci sia del codice per farlo esplicitamente nel metodo figlio. Il metodo della superclasse non apparirà affatto nello stack delle chiamate, a meno che non venga chiamato esplicitamente dal metodo figlio.

class A { 
    void play1() { 
    //... 
    } 
    void play2() { 
    //.... 
    } 
} 
class B extends A { 
    void play1() { 
    //... 
    } 
} 
B b = new B(); 
b.play1(); // 'first' call 
b.play2(); // 'second' call 

A.play2() appare sullo stack di chiamata solo durante "seconda chiamata". B.play1() appare sullo stack delle chiamate solo durante "first call". A.play1() non appare mai nello stack delle chiamate e non viene mai eseguito.

+0

Ok! intendi dire che il metodo della superclasse appare solo quando viene chiamato esplicitamente da una sottoclasse. –

2

C'è solo uno stack di chiamate per thread, quindi no, entrambe le chiamate playX si verificano nello stesso stack.

Non sono sicuro del motivo per cui pensi che non lo farebbero o che cosa ha a che fare con l'ereditarietà. Forse, se tu fornissi un esempio specifico del perché pensi che questo sia importante (cioè un caso in cui il comportamento sarebbe notevolmente diverso), ciò aiuterebbe ad affrontare ciò che è presumibilmente un problema più profondo.