consiglio design riguardo metodi sovrascritti

[Mr.Bloom]

Ciao a tutti,

supponiamo che abbia una classe con un metodo "call" che fa alcune operazioni e poi chiama attiva del listeners registrati precedentemente :

class class  superClass{

   public void call(){
     operationA();
     operationB();
     fireRegisteredListeners();
   }
} 

e poi ho una sottoclasse che deve aggiungere una nuova operazione "operationC" che dovrebbe essere eseguita dopo A e B ma prima di richiamare i listeners.
ovviamente se sovrascrivo semplicemente il metodo in questo modo

publlic class subClass extends superClass{
  public void call(){
      super.call();
      operationC();
      fireRegisteredListeners();
} 

ho che il metodo fireRegisteredListener e' richiamato due volte.

il problema e' che "super" e' ottimo quando si vogliono aggiungere istruzioni all'inizio o alla fine del metodo della classe padre ma non quando si vorrebbero aggiungere nel mezzo!
Vi viene in mente un modo elegante per realizzare questa cosa senza reimplementare l'intero metodo da capo?

grazie
MB

[lolide]

E se sovrascrivi (fai l'override di) fireRegisteredListeners chiamando prima operationC poi super.fireRegisteredListeners ?

[VincenzoTheBest]

Originariamente inviato da Mr.Bloom
il problema e' che "super" e' ottimo quando si vogliono aggiungere istruzioni all'inizio o alla fine del metodo della classe padre ma non quando si vorrebbero aggiungere nel mezzo!

Il problema non sta in quello..sarebbe bastato solo far bene le ridefinizioni.

[unomichisiada]

class class  superClass{

   public void call(){
       beforeRegisteredListeners();
       fireRegisteredListeners();
       afterFireRegisteredListeners();
    }
   protected beforeRegisteredListeners()
   {
        operationA();
        operationB();
   }

    protected afterFireRegisteredListeners()
    {
    }
}


public class subClass extends superClass{
     public void call(){
        super.call();
    }
    protected afterFireRegisteredListeners()
    {
        operationC();
    }
}

Fatto così come lo vedi?

[unomichisiada]

Ops...mi sa che ho letto male ingnora...

[unomichisiada]

class class  superClass{

   public void call(){
       beforeRegisteredListeners();
       fireRegisteredListeners();
       afterFireRegisteredListeners();
    }
   protected beforeRegisteredListeners()
   {
        operationA();
        operationB();
   }

    protected afterFireRegisteredListeners()
    {
    }
}


public class subClass extends superClass{
     public void call(){
        super.call();
    }
    protected beforeFireRegisteredListeners()
    {
        super.beforeFireRegisteredListeners();
        operationC();
    }
}

Ma rivisto così dovrebbe andare

[lolide]

Così no eh ?

public class superClass{

   public void call(){
       operationA();
       operationB();
       fireRegisteredListeners();
    }
}


public class subClass extends superClass{
    protected fireRegisteredListeners()
    {
        operationC();
        super.fireRegisteredListeners();
    }
}

[unomichisiada]

Originariamente inviato da lolide
Così no eh ?

public class superClass{

   public void call(){
       operationA();
       operationB();
       fireRegisteredListeners();
    }
}


public class subClass extends superClass{
    protected fireRegisteredListeners()
    {
        operationC();
        super.fireRegisteredListeners();
    }
}

Chiaramente funzionerebbe, ma fireRegisteredListeners non farebbe SOLO lanciare gli eventi per i listener. E' puramenet una questione stilistica, lo ammetto , ma mi piace meno.

[Mr.Bloom]

grazie della vostra risposta.