[JAVA]: Classi e costruttori

[vitto999]

Vorrei sapere perchè questo codice:


public class MainClass2 {
public static void main(String args[]) {
C1 c=new C1(); }}

------------------------------
abstract class A1 {
A1() {
System.out.println("A"+m1());
m1();}

abstract public int m1();
}

------------------------------------------

class B1 extends A1 {
B1() {
System.out.println("D");}
public int m1() {return 10;}}
---------------------------------------

class C1 extends B1 {
C1() {System.out.println("C");}}
--------------------------------------

Perchè stampa A10 D C !?

vorreste spiegarmelo!?

grazie.....

[andbin]

Originariamente inviato da vitto999
Perchè stampa A10 D C !?

vorreste spiegarmelo!?

Innanzitutto devi capire come funzionano i costruttori (perché se hai fatto questa domanda, non lo sai).
Ogni classe, che tu ce lo metta oppure no, ha un costruttore.

Se non definisci alcun costruttore, il compilatore ne mette uno di default del tipo:

<modo accesso> NomeClasse ()
{
    super ();
}

dove <modo accesso> è lo stesso della classe.

Se invece tu definisci almeno 1 costruttore, il compilatore non aggiunge alcun costruttore di default.
Se tu metti un costruttore del tipo:

C1()
{
    System.out.println("C");
}

il compilatore comunque mette all'inizio un super(); in modo che diventi:

C1()
{
    super();
    System.out.println("C");
}

Questo perché un costruttore, in un modo o in un altro, deve comunque chiamare sempre un costruttore della super-classe!!!
In realtà ci sarebbe molto altro da dire sui costruttori ma ... per il momento mi fermo qui.

Il tuo codice quindi fa questo:

- Nel main istanzi un oggetto di tipo C1.
- Il costruttore di C1, avendo un super() implicito, chiama il costruttore di B1.
- Il costruttore di B1, avendo un super() implicito, chiama il costruttore di A1.
- Il costruttore di A1, avendo un super() implicito, chiama il costruttore della super-classe (che è Object e che non fa nulla).
- Il costruttore di A1 poi stampa "A" e siccome m1() è stato messo in override nella classe B1, per "polimorfismo", viene chiamato quel metodo che ritorna 10, quindi stampa "10" dopo la "A".
- Il costruttore di A1 termina e si ripassa al costruttore di B1 che stampa "D".
- Il costruttore di B1 termina e si ripassa al costruttore di C1 che stampa "C".

Ecco il perché della stampa "A10DC".

[vitto999]

Vero hai ragione... non so come mi sono dimenticato l'invocazione implicita del costruttore della superclasse. roba da matti!

ti ringrazione cmq per la spiegazione, mi hai riportato alla realtà!!!

ciao!

[alka]

Originariamente inviato da vitto999
[JAVA] . chi mi spiega cosa semplice!?

Suggerisco un titolo più consono in futuro e, soprattutto, l'inoltro della domanda al forum dedicato al linguaggio Java.

Il titolo l'ho corretto io, così come ho spostato la discussione.