Forza il metodo non astratto da sovrascrivere

Question

Ho un metodo String foo() in una classe astratta che già esegue alcune precomputazioni ma non è in grado di fornire il risultato finale che si suppone che il metodo restituisca. Quindi quello che voglio è che ogni classe non astratta che eredita dalla mia classe astratta deve implementare foo in un modo che viene chiamato prima super() e quindi il risultato è calcolato. C'è un modo per forzare questo in Java?

Answer 1

Sì, ridisegnando di utilizzare la template method pattern e comprendente un metodo astratto:

public abstract class AbstractSuper { 
    public final String foo() { 
     // Maybe do something before calling bar... 
     String initialResult = bar(); 
     // Do something common, e.g. validation 
     return initialResult; 
    } 

    protected abstract String bar(); 
} 

In pratica se si vuole forzare sottoclassi per scavalcare un metodo, fa devono essere astratto - ma che doesn' t deve essere il metodo che viene chiamato da altro codice ...

Answer 2

Non c'è modo di farlo in Java. Comunque puoi dichiarare un altro metodo che è astratto e chiamalo. Come questo:

public final String foo() { 
    String intermediate = ... // calculate intermediate result; 
    return calculateFinalResult(intermediate); 
} 

protected abstract String calculateFinalResult(String intermediate); 

In questo modo si sarà costretti a ignorare calculateFinalResult. Non è necessaria alcuna chiamata dell'istanza super. Anche le sottoclassi non saranno in grado di ridefinire il tuo foo() come dichiarato come final.

Answer 3

Qualcosa di simile?

public abstract class MyBean { 

    public final String foo(){ 
     String preFinalResult = [...]; 
     return doFinalResult(preFinalResult) 
    } 

    protected abstract String doFinalResult(String preFinal); 
}