Uso del costruttore privato nella classe

Question

Se esiste un costruttore privato, la JVM inserisce una chiamata al super costruttore?

Mi riferisco alla chiamata super() in tale costruttore privato.

class Alpha { 
    static String s=""; 
    protected Alpha(){ 
     s+="alpha"; 
    } 
} 

class SubAlpha extends Alpha{ 
    private SubAlpha(){ 
     s+="sub"; 
    } 
} 

class SubSubAlpha extends Alpha{ 
    private SubSubAlpha(){ 
     s+="subsubAlpha"; 
    } 

    public static void main(String[] args){ 
     new SubSubAlpha(); 
     System.out.print(s); 
    } 
} 

Qui non si ottiene alcun errore di compilazione. Qui nella classe SubSubAlpha c'è un costruttore privato. È che il compiler inserisca la chiamata super() in questo caso, cosa succede nella classe SubAlpha. Anche lì c'è un costruttore privato. E se non si accede a ciò, l'albero ereditario continua fino in cima.

Answer 1

Sì. Il costruttore privato ha una chiamata implicita super() se non è esplicita la chiamata del costruttore super o this. In questo senso, non è diverso dagli altri costruttori. Naturalmente, affinché questo possa essere compilato, la superclasse deve avere un costruttore no-args visibile dalla classe.

Tuttavia, se un costruttore è private, non può essere chiamato da una sottoclasse ... o da qualsiasi altro codice a parte la classe stessa.

Answer 2

Ya, è possibile utilizzare super() per utilizzare la funzione e l'attributo della superclasse. la sua lo stesso con java normale

Answer 3

Se c'è costruttore privato fa gli inserti JVM chiamano al costruttore eccellente?

Sì

Il costruttore eccellente sarà sempre essere chiamati. (Non è possibile creare un'istanza di una classe, anche senza istanziare la super classe allo stesso tempo.)

Se non lo fai in modo esplicito da soli, ci sarà una chiamata implicita inserito per voi, non importa se il costruttore è privato o pubblico.

---

essere pignoli: In realtà non è la JVM che inserisce, ma il compilatore Java:

public class Test { 
    private Test() { 
    } 
} 

è compilato in

private Test(); 
    Code: 
    Stack=1, Locals=1, Args_size=1 
    0: aload_0 
    1: invokespecial #1; //Method java/lang/Object."<init>":()V 
    4: return 

Answer 4

Il motivo per cui non si ottiene un errore in fase di compilazione è che la gerarchia di classi non è quella che si pensa. Penso che volevi dire questo:

class SubSubAlpha extends Alpha { 

essere questo:

class SubSubAlpha extends SubAlpha { 

... a quel punto sarete davvero ottenere un errore di compilazione.

(In altre parole, sì, c'è è sempre una chiamata al super-costruttore.)

Answer 5

Questo è un bell'esempio da Java Programmer's SourceBook. Poiché i costruttori stampano quando chiamati, vedrai immediatamente la sequenza delle chiamate. È da Pensare in Java.

//: Cartoon.java 
// Constructor calls during inheritance 

class Art { 
    Art() { 
    System.out.println("Art constructor"); 
    } 
} 

class Drawing extends Art { 
    Drawing() { 
    System.out.println("Drawing constructor"); 
    } 
} 

public class Cartoon extends Drawing { 
    Cartoon() { 
    System.out.println("Cartoon constructor"); 
    } 
    public static void main(String[] args) { 
    Cartoon x = new Cartoon(); 
    } 
} ///:~ 

L'output di questo programma mostra i chiamate automatiche:

costruttore Art
costruttore Disegno costruttore
fumetto