Ereditarietà del costruttore Java?

Question

Ho sempre pensato che i costruttori non sono ereditate, ma un'occhiata a questo codice:

class Parent { 

Parent() { 
    System.out.println("S1"); 
} 

} 
class Child extends Parent { 

Child(){ 

    System.out.println("S2"); 
} 


} 

public class Test5 { 
public static void main(String[] args) { 
    Child child = new Child(); 

} 
} 

//RESULT: 
//S1 
//S2 

Esso dimostra che Bambino ereditato costruttore. Perché c'è S1 sul risultato? C'è qualche possibilità di creare 2 costruttori senza parametri e avere solo il costruttore di Child sul risultato senza il costruttore di base (solo S2) ??

Answer 1

Java doc dice:

A subclass inherits all the members (fields, methods, and nested classes) from its superclass. Constructors are not members, so they are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass.

Se non si dichiara un costruttore di qualsiasi tipo, viene aggiunto un valore predefinito.

Se non si chiama nessun altro costruttore nella prima riga della sottoclasse, viene effettuata una chiamata a super().

Answer 2

Il costruttore non viene ereditato.

Il costruttore di super classe non è ereditato nella classe derivata.

Esiste la possibilità di creare 2 costruttori senza parametri e avere solo costruttore Child nel risultato senza costruttore di base.

No, non è possibile In Java ogni costruttore di classe derivata chiama il costruttore super-classe. Se non lo aggiungi, chiama no argument constructor.

public SuperClass() { 
    ... 
} 

public DerivedClass() { 
    //Compiler here call no argument constructor of Super class. 
} 

Answer 3

Lei scrive:

Esso dimostra che Bambino ereditato costruttore.

I costruttori non possono essere ereditati. Le classi possono essere ereditate, quindi Child non eredita alcun costruttore. Il bambino eredita il genitore della classe. Il genitore eredita l'oggetto di classe. Quando chiamate il costruttore Child, automaticamente viene chiamato un costruttore Object e quindi un costruttore Parent, prima dell'esecuzione del codice del costruttore Child.

questo il motivo per cui si ottiene questo risultato:

S1 
S2 

Answer 4

Qualunque cosa si sta vedendo qui è chiamato come costruttore concatenamento. Now What is Constructor Chaining:

Il concatenamento del concatenamento avviene tramite l'uso dell'ereditarietà. Un sottoprogramma per il primo metodo del costruttore è chiamare il suo metodo costruttore della superclasse. Ciò garantisce che la creazione dell'oggetto della sottoclasse inizi con con l'inizializzazione delle classi sopra di esso nella catena ereditaria .

Potrebbe esserci un numero qualsiasi di classi in una catena di ereditarietà. Ogni metodo di costruzione richiamerà la catena fino a quando la classe in alto è stata raggiunta e inizializzata.Quindi, ogni classe successiva di seguito è inizializzata mentre la catena torna indietro alla sottoclasse originale. Questo processo è chiamato costruttore di concatenamento. (Source)

Questo è ciò che accade nel vostro programma. Quando si compila il programma, il Child è compilato per questo modo da javac:

class Child extends Parent 
{ 
    Child() 
    { 
    super();//automatically inserted here in .class file of Child 
    System.out.println("S2"); 
    } 
} 

E la classe genitore è convertito al seguente:

Parent() 
{ 
    super();//Constructor of Object class 
    System.out.println("S1"); 
} 

Ecco perché l'output sta mostrando come:

S1 //output from constructor of super class Parent 
S2 //output from constructor of child Class Child 

Answer 5

Un costruttore chiamerà sempre il costruttore della superclasse a meno che non sia stato definito un costruttore esplicito. Dal Java Language Specification:

Se un corpo del costruttore non inizia con un'invocazione costruttore esplicito e il costruttore di essere dichiarato non è parte della classe Object primordiale, poi il corpo del costruttore inizia implicitamente con un costruttore della superclasse invocazione "super (); ", un'invocazione del costruttore della sua superclasse diretta che non accetta argomenti.