È corretto chiamare il metodo astratto dal costruttore in Java?

Question

Supponiamo di avere una classe Base astratta che implementa l'interfaccia Runnable.

public abstract class Base implements Runnable { 

    protected int param; 

    public Base(final int param) { 
     System.out.println("Base constructor"); 
     this.param = param; 
     // I'm using this param here 
     new Thread(this).start(); 
     System.out.println("Derivative thread created with param " + param); 
    } 

    @Override 
    abstract public void run(); 
} 

E qui è una delle poche classi derivate.

public class Derivative extends Base { 

    public Derivative(final int param) { 
     super(param); 
    } 

    @Override 
    public void run() { 
     System.out.println("Derivative is running with param " + param); 
    } 

    public static void main(String[] args) { 
     Derivative thread = new Derivative(1); 
    } 

} 

Il punto è che voglio che la mia classe Base faccia delle cose generali invece di copiarle ogni volta. In realtà, è in esecuzione bene, l'uscita è sempre lo stesso:

costruttore di base filo derivativa creata con param 1 derivativo è in esecuzione con param 1

Ma è sicuro in Java per avviare una discussione chiamando il metodo astratto nel costruttore? Perché, in C++ e C# non è sicuro nella maggior parte dei casi, per quanto ne so. Grazie!

Answer 1

Questo codice dimostra il motivo per cui si dovrebbe mai chiamata di un metodo astratto, o qualsiasi altro metodo override, da un costruttore:

abstract class Super { 
    Super() { 
     doSubStuff(); 
    } 
    abstract void doSubStuff(); 
} 

class Sub extends Super { 
    String s = "Hello world"; 

    void doSubStuff() { 
     System.out.println(s); 
    } 
} 

public static void main(String[] args) { 
    new Sub(); 
} 

Quando eseguito, viene stampato null. Ciò significa che i soli metodi "sicuri" di avere in un costruttore sono privati ​​e/o finali.

D'altra parte, il tuo codice in realtà non chiama un metodo astratto da un costruttore. Invece, si passa un oggetto non inizializzato a un altro thread per l'elaborazione, il che è peggio, dal momento che il thread che si sta iniziando può avere priorità e deve essere eseguito prima che l'Base termini l'inizializzazione.

Answer 2

È molto difficile chiamare un metodo astratto da un costruttore. I metodi richiamati dai costruttori dovrebbero sempre essere privati ​​o finali, per impedire l'override.

Vedi questo link per una domanda here

Answer 3

Non

una buona idea, dato che quando viene eseguito() viene richiamato, l'oggetto derivato potrebbe non essere stato inizializzato. Se run() dipende da qualsiasi stato in derivato, può fallire.

Nel tuo caso semplice funziona. Ma allora non ha senso per la sottoclasse. Si può semplicemente

public Base(final int param, Runnable action) { 

    new Thread(action).start(); 

Answer 4

Il passaggio di this al di fuori del costruttore si chiama "lasciando il this escape dal costruttore" e può causare alcuni bug particolarmente fastidiosi, perché l'oggetto potrebbe trovarsi in uno stato incoerente.

Questo è il caso in particolare quando this viene passato a un altro thread, come in questo esempio. A causa del diritto JVM di riordinare le istruzioni all'interno di un thread, è possibile ottenere un comportamento/stato non definito che si verifica.