Salve, oggi vorrei parlarvi di un argomento riguardante Java molto importante ma al 
tempo stesso utilissimo per una risoluzione pratica ed elegante di problemi di qualunque 
genere.
In poche parole introdurrò i costruttori sovraccarichi.
Per capire effettivamente cos'è un costruttore sovraccarico possiamo pensare direttamente 
ai metodi. Java sappiamo tutti che offre l'importantissimo overloading dei metodi, ossia 
è perfettamente lecito dichiarare più metodi aventi lo stesso e medesimo nome a patto che 
essi abbiano numero e tipo di parametri differenti.

Facciamo subito un esempio:

public String formatString(Stringa a, String b) { ... }
public String formatString(int a, int b) { ... }

Queste due funzioni hanno lo stesso nome formatString() e restituiscono il medesimo tipo di 
dato String (return .. ), in un qualsiasi linguaggio di programmazione il compilatore vi 
segnelerà un errore logico, in Java invece rappresentano due espressioni validissime 
poiché i due metodi accettano parametri diversi e  di conseguenza, dopo aver creato un 
oggetto object scrivendo object.formatString(ciao,bye), il compilatore notando i due 
argomenti di tipo String è a conoscenza di quale metodo usare.

I costruttori sovraccarichi sono più o meno la stessa cosa.
Possiamo dichiarare all'interno di una classe molti tipi di costruttori sovraccarichi, 
aventi stesso nome, ma che accettano parametri diversi e che quindi possono aiutarci ad 
inizializzare un oggetto a seconda delle nostre esigenze. Infatti i costruttori sovraccarichi 
risultano una validissima scelta nella creazione di apposite librerie che permettono di 
inizializzare un oggetto nei più svariati modi.
Tutti sappiamo che all'utilizzo dell'operatore new per la creazione di oggetti corrisponde 
una vigile chiamata ad un costruttore, che esso sia dichiarato o meno (costruttore di 
default in quel caso).

Facciamo subito un po' di pratica.
Un costruttore di default della classe Test verrebbe dichiarato nel seguento modo:

public Test () { .. } 

ma come abbiamo scoperto poco prima, l'overloading ci viene in aiuto nelle esigenze 
in cui dobbiamo creare un oggetto un po' "particolare", poiché all'interno della stessa 
classe possiamo dichiarare altri costruttori con numero e tipi di parametri diversi e 
farli comunicare fra di loro.

Esempio di costruttori "comunicanti" (comunicanti non è il termine più appropriato).

public Test() 
{
this (0,0) // referenzia quindi invoca il costruttore che ha due parametri di tipo int 
e assegna valore 0 a first e second perchè invocato senza alcun parametro
}
public Test(int first, int second) 
{
... metodi opportuni ...
} // costruttore "padre" poiché può inizializzare l'oggetto specificando i valori come argomenti al momento dell invocazione => Test(3,5) first = 3 second = 5

Questo è solo un piccolo esempio che vede l'uso della parole chiave this che mette in 
una sorta di comunicazione i due costruttori, infatti usando Test object = new Test() 
inizializzeremo a 0 i due valori ed eseguiremo i metodi espressi nel costruttore padre 
(chiamato padre solo per distinzione dall'altro).
 
In problematiche differenti potremmo usare il costruttore di default per inizializzare 
l'oggetto in un certo modo ed eseguire certe operazioni con i metodi, e il costruttore 
con argomenti per inizialiazzare l'oggetto in altri modi ed eseguire altri tipi di operazioni.
L'argomento dei costruttori sovraccarichi meriterebbe molta più attenzione del dovuto, 
nonostante questo spero di essere stato il più chiaro possibile nel presentarvi queste 
piccole nozioni, alla prossima! 

f0rbid,
:)