È sempre sicuro chiamare getClass() all'interno del costruttore della sottoclasse?

Question

An article on classloading afferma che il metodo getClass() non dovrebbe essere chiamato all'interno di un costruttore perché:

inizializzazione oggetto sarà completa solo all'uscita del codice costruttore.

L'esempio hanno dato era:

public class MyClassLoader extends ClassLoader{ 
    public MyClassLoader(){ 
     super(getClass().getClassLoader()); // should not call getClass() because object 
              // initialization will be complete only at 
              // the exit of the constructor code. 
    } 
} 

Tuttavia da quello che so, il metodo finale nativo getClass() sarà sempre restituire l'oggetto di tale istanza oggetto java.lang.Class, indipendentemente dove si chiama (in un raggio il costruttore o no).

Chiamando getClass() all'interno del costruttore sempre ci danno problemi?

In tal caso, quali sono alcuni esempi per cui chiamare il numero getClass() all'interno del costruttore potrebbe darci errori?

Answer 1

Chiamare getClass() all'interno del costruttore ci dà mai problemi? Se sì, quali sono alcuni esempi per cui chiamare getClass() all'interno del costruttore sarebbe darci errori?

Utilizzando getClass() nel costruttore in questo modo sarà sempre risultato in un errore di compilazione, in quanto this non può essere fatto riferimento prima super() è stato chiamato.

Main.java:17: error: cannot reference this before supertype constructor has been called 
     super(getClass().getClassLoader()); // should not call getClass() because object 
      ^
1 error 

È possibile testarlo su http://ideone.com/B0nYZ1.

Il Class è pronto, ma la esempio non può essere utilizzato per fare riferimento alla Class ancora.

Ancora, si possibile utilizzare il riferimento Class nel costruttore, ma devi farlo in un modo leggermente diverso: super(MyClassLoader.class.getClassLoader())

Inoltre, si è liberi di utilizzare getClass() nel costruttore dopo il supertipo il costruttore è stato chiamato - come hai già sottolineato, l'oggetto è fondamentalmente pronto dopo e il riferimento Class può essere dedotto dall'istanza.

Answer 2

La ragione per cui non si dovrebbero chiamare i metodi della classe genitore, almeno in una chiamata super(), è che poiché l'oggetto padre deve ancora essere creato, non c'è modo di sapere se il metodo verrà eseguito correttamente. Devi ricordare che la chiamata avviene prima che i costruttori genitori abbiano la possibilità di preparare i suoi dati.

Dopo un'invocazione super(), si dovrebbe essere abbastanza sicuri di utilizzare i metodi padre, entro limiti ragionevoli, poiché gli oggetti padre hanno tutti completato ciò di cui hanno bisogno per essere considerati pronti per l'uso. Ho visto entro limiti ragionevoli perché i metodi genitore possono chiamare metodi figlio sovrascritti che è necessario garantire che siano sicuri da chiamare durante la costruzione.

Unsafe:

public static class Base { 
    public final void print() { 
     System.out.println(this.get()); 
    } 

    public int get() { 
     return 2; 
    } 
} 

public static final class Sub extends Base { 

    private int x; 

    public Sub() { 
     super(); 
     this.print(); 

     this.x = 1; 
    } 

    public int get() { 
     return this.x; 
    } 
} 

Sicuro:

public static class Base { 
    public final void print() { 
     System.out.println(this.get()); 
    } 

    public int get() { 
     return 2; 
    } 
} 

public static final class Sub extends Base { 

    private int x; 

    public Sub() { 
     super(); 
     this.x = 1; 

     this.print(); 
    } 

    public int get() { 
     return this.x; 
    } 
} 

Modifica - Modifica: Dopo ritentare il seguente codice e chiamare getClass(), in realtà non compilare. Quindi ignorare completamente le precedenti dichiarazioni su Object.getClass() che è l'unico metodo disponibile per chiamare prima dell'inizializzazione del genitore. Non ho idea di come sia mancato, e mi dispiace per ogni confusione.

Answer 3

$ javac whose/MyClassLoader.java 
whose/MyClassLoader.java:5: error: cannot reference this before supertype constructor has been called 
     super(getClass().getClassLoader()); 
      ^
1 error 

So che è tardi.