Come assicurarsi che un determinato metodo venga chiamato in super-classe astratta dal metodo in sottoclasse (Java)

Question

Ho una super classe astratta A con un metodo doSomething(). Una sottoclasse di A deve implementare doSomething(), ma esiste anche un codice comune che dovrebbe essere chiamato ogni volta che una sottoclasse chiama doSomething(). So che questo potrebbe essere realizzato così:

public class A { 
    public void doSomething() { 
    // Things that every sub-class should do 
    } 
} 

public class B extends A { 
    public void doSomething() { 
    super.doSomething(); 
    // Doing class-B-specific stuff here 
    ... 
    } 
} 

Sembra che ci siano tre problemi con questo, però:

• Il metodo firme devono corrispondere, ma potrei voler restituire qualcosa in sub- solo metodi di classe, ma non nella super-classe
• Se faccio astratto A.doSomething(), non posso fornire un'implementazione (comune) in A. Se non lo faccio astratto, non posso forza la sottoclasse per implementarla.
• Se si utilizza un metodo diverso per fornire la funzionalità comune, non è possibile imporre che B.doSomething() chiama questo metodo comune.

Qualche idea su come devono essere implementati i metodi?

Answer 1

add chiamata al doSomething()

public class A { 
    public void doSomething() { 
    // Things that every sub-class should do 
    doSomethingMore() 
    } 
} 

protected abstract void doSomethingMore() 

così tutti subclusses dovrà ipmelment doSomethingMore() con azioni aggiuntive, ma classi esterne chiamerà doSomething pubblico()

Answer 2

E i seguenti?

public abstract class A { 
    protected abstract void __doSomething(); 

    public void doSomething() { 
    // Things that every sub-class should do 
    __doSomething(); 
    } 
} 

public class B extends A { 
    protected void __doSomething() { 
    // Doing class-B-specific stuff here 
    ... 
    } 
} 

Tuttavia, il primo punto non è chiaro. La firma non può corrispondere se si desidera restituire qualcosa di diverso.

Answer 3

Per primo punto da solo - si può prendere in considerazione la risposta di seguito e per imporre l'implementazione della sottoclasse può essere astratto ma chiamare funzionalità di codice comune può accadere se la classe base ha qualche implementazione.

Il tipo di reso può essere Object in Base Class e restituire null. Nella sottoclassifica il tipo di reso specifico può essere inserito come indicato di seguito.

public class InheritanceTutorial { 

    static class Base{ 
     public Object doSomething(){ 
      System.out.println("parent dosomething"); 
      return null; 
     } 
    } 

    static class SubClass extends Base{ 
     public Integer doSomething(){ 
      super.doSomething(); 
      System.out.println("child dosomething"); 
      return 0; 
     } 
    } 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     SubClass subClass = new SubClass(); 
     subClass.doSomething(); 
    } 

}