[Java] Costruttori di superclassi: dubbio

[Gica78R]

Ciao...

ho un problema nel capire il funzionamento dei costruttori si una classe derivata. Riporto uno stralcio un po' ambiguo tratto dalla guida che sto studiando (Java 2 SDK 1.4, Apogeo):

Tecnicamente i metodi costruttori non possono essere ridefiniti, perche' devono sempre avere lo stesso nome della classe corrente; di conseguenza, vengono creati nuovi costruttori anziche' fare in modo che vengano ereditati. Questo sistema funziona nella maggior parte dei casi: quando viene richiamato il metodo costruttore di una classe, viene richiamato anche il costruttore con la stessa segnatura di tutte le superclassi della classe in questione. Quindi l'inizializzazione ha luogo per tutte le parti di una classe che vengono ereditate.

Leggendo quanto sopra, io capisco che, se nella classe Derivata dalla classe Base definisco un costruttore con due argomenti, quando vado a creare un oggetto con

Derivata d = new Derivata(a,b);

in questo modo viene anche invocato il costruttore a due argomenti della classe Base. Pero' all'atto pratico ho notato che in realta' viene invocato il costruttore senza argomenti della classe Base.

Riporto un esempio:

/* Classe base */
class Primo {
	int x, y;
	
	public Primo(int x, int y) {
		this.x = x;
		this.y = y;
	}
	
	public Primo(int x) {
		this(x, 1);
	}
	
	
	void Stampa() {
		System.out.println("X = "+x+" Y = "+y);
	}
	
}


/* Classe derivata */
public class Secondo extends Primo {
	int z;
	
	public Secondo(int x, int y) {
		this.z=0;
	}
	
	public Secondo(int x) {
		this.z=-1;
	}
	
	public Secondo(int x, int y, int z) {
		super(x, y);
		this.z = z;
	}
	
	void Stampa() {
		System.out.println("X = "+x+" Y = "+y+" Z = "+z);
	}
	
	public static void main(String [] argomenti) {
		Primo a = new Primo(23, 67);
		Secondo b = new Secondo(23, 67);
		Secondo c = new Secondo(23);
		
		System.out.print("A) ");
		a.Stampa();
		System.out.print("B) ");
		b.Stampa();
		System.out.print("C) ");
		c.Stampa();
	}
}

Se tento di compilare il programma, ottengo due errori sui costruttori con uno e due argomenti della classe Secondo, poiche' non e' definito un costruttore senza argomenti della classe Primo (classe da cui Secondo deriva). Nel costruttore con tre argomenti della classe Secondo, invece, invoco esplicitamente il costruttore a due argomenti di Primo, per cui non ottengo errori...

Mi spieghereste se sono io che interpreto male il testo della guida, oppure se e' la guida che si spiega male? Oppure ho sbagliato qualcosa nell'esempio che ho riportato?


Grazie

[NA01]

secondo quanto scrive thinking in java è corretto che ti dia errore.
cito la traduzione alla seconda edizione:

Se non dichiarate il costruttore alla classe base in BoardGame(), il compilatore si lamenterà che non può trovare un costruttore della forma Game().

capisco che non abbia molto senso questa frase senza avere le classi davanti , ma è esattamente la tua situazione.
La classe base ha il suo costruttore, e ha bisogno di uno o più argomenti, quindi quello di default senza argomenti non esise più.
se nella derivata non si specifica con super a qunto spiega thinking in java il compilatore va a cercare quelli di default. se è stato ridefinito un costruttore questo non esiste più e hai un errore.

ciao!

[Brazorv]

Originariamente inviato da Gica78R

Leggendo quanto sopra, io capisco che, se nella classe Derivata dalla classe Base definisco un costruttore con due argomenti, quando vado a creare un oggetto con

Derivata d = new Derivata(a,b);

in questo modo viene anche invocato il costruttore a due argomenti della classe Base. Pero' all'atto pratico ho notato che in realta' viene invocato il costruttore senza argomenti della classe Base.

Se non chiami esplicitamente il costruttore della calsse base con super, viene chiamato il costruttore di default della classe base non il costruttore con gli stessi argomenti della classe derivata.

[Gica78R]

Originariamente inviato da Brazorv

Se non chiami esplicitamente il costruttore della calsse base con super, viene chiamato il costruttore di default della classe base non il costruttore con gli stessi argomenti della classe derivata.

Ok... quindi concordate con me che quanto riportato dalla mia guida ( ) sia un po' ambiguo?
Quando dice "...costruttore con la stessa segnatura di tutte le superclassi..." io sono portato a pensare che, se stai definendo un costruttore con due argomenti int, allora viene richiamato il costruttore con due argomenti int della superclasse.

Vi ringrazio per aver confermato i miei sospetti!


Gica