Tutti i metodi, nessuno o alcuni metodi sovrascritti chiamano Super?

Naviga le tue risposte
6

Durante la progettazione di una classe, come decidi quando i tutti metodi sovrascritti dovrebbero chiamare super o quando nessuno dei metodi sottoposti a override deve chiamare super ? Inoltre, è considerata una cattiva pratica se la logica del codice richiede una combinazione di metodi superati e non superati come l'esempio di Javascript qui sotto? 

ChildClass = new Class.create(ParentClass,
{
   /**
    * @Override
    */
   initialize: function($super) {
      $super();
      this.foo = 99;
   },

   /**
    * @Override
    */
   methodOne: function($super) {
      $super();
      this.foo++;  
   },


   /**
    * @Override
    */
   methodTwo: function($super) {
      this.foo--;  
   }
});

Dopo aver approfondito gli SDK iPhone e Android, ho notato che super deve essere richiamato su ogni metodo sovrascritto, altrimenti il programma si arresterà in modo anomalo perché qualcosa non verrebbe inizializzato. Quando viene derivato da un modello / delegato, viene superato nessuno dei metodi (ovviamente). Quindi, quali sono esattamente queste qualità "je ne sais quoi" che determinano se un tutti , nessuno o alcuni metodi sovrascritti dovrebbe chiamare super?

    
posta JoJo 24.06.2011 - 22:45
fonte

2 risposte

9

Secondo Martin Fowler, questo è anti-pattern .

Penso che sia una buona lettura, se non conosci già quell'articolo.

Call Super is a minor smell (or anti-pattern if you like) that crops up from time to time in OO frameworks. Its symptoms are pretty easy to spot. You are inheriting from a super-class in order to plug into some framework. The documentation says something like "to do your own thing, just subclass the process method. However it's important to remember to start your method with a call to the super-class". An example might be something like this.

public class EventHandler ...
  public void handle (BankingEvent e) {
    housekeeping(e);
  }
public class TransferEventHandler extends EventHandler...
  public void handle(BankingEvent e) {
    super.handle(e);
    initiateTransfer(e);
  }

Whenever you have to remember to do something every time, that's a sign of a bad API. Instead the API should remember the housekeeping call for you. The usual way to do this is to make the handle method a Template Method, like this.

public class EventHandler ...
  public void handle (BankingEvent e) {
    housekeeping(e);
    doHandle(e);
  }
  protected void doHandle(BankingEvent e) {
  }
public class TransferEventHandler extends EventHandler ...
  protected void doHandle(BankingEvent e) {
    initiateTransfer(e);
  }

Here the super-class defines the public method and provides a separate method (often referred to as a hook method) for the subclass to override. The subclass writer now doesn't have to worry his ugly head about calls to super. Furthermore the super-class writer is free to add calls after the subclass method if she wishes...

    
risposta data 24.06.2011 - 22:55
fonte
2

Se si debba o meno chiamare super dipende dal fatto che si stia tentando di aggiungere alla funzionalità esistente del metodo o di sostituirlo. Ciò dipende totalmente da ciò che il metodo sta facendo e in alcuni casi può anche dipendere dai parametri.

    
risposta data 04.12.2015 - 19:33
fonte

Leggi altre domande sui tag

Esiste una ragione fondamentale per tenere separati i file system e i sistemi di controllo delle versioni? Ci sono dei veri benefici per un livello DAO?