Okay, questo contesto ci aiuta a capire cosa stavi cercando di fare: ti hanno spiegato i getter e i setter e stavi facendo qualche esperimento per capire meglio cosa sono, perché esistono e quando utili o inutili. Nel fare questi esperimenti ti sei accorta di avere qualche dubbio sul funzionamento dei costruttori. Giusto?
Nella programmazione object-oriented creiamo dei tipi astratti (e.g. il tipo Studente). Questi tipi sono caratterizzati da dei campi (e.g., nome, cognome e matricola) e da dei metodi (e.g., iscriviAlCorso). I campi descrivono lo stato dell'oggetto (i.e., com'è fatto in questo momento) mentre i metodi descrivono le azioni che può svolgere. Tra i vari metodi ce n'è uno speciale, chiamato costruttore, che implementa l'azione di creare un oggetto e viene chiamato
automaticamente nel momento in cui usiamo l'operatore
new. Con
Java:
public class Persona {
private String nome;
private String cognome;
public Persona(String nome, String cognome) {
this.nome = nome;
this.cognome = cognome;
}
}
stiamo descrivendo l'oggetto persona con due campi (nome e cognome); il costruttore specifica che per creare un oggetto persona hai bisogno di specificare due parametri: nome e cognome.
Se non creiamo nessun costruttore (come hai fatto te), java ne scrive uno al posto nostro che non prende nessun parametro. Quindi se scriviamo
Java:
public class Persona {
private String nome;
private String cognome;
// public Persona() {}
}
java scrive al posto nostro il costruttore che io ho scritto commentato. Se scriviamo noi un costruttore, java non scrive il costruttore di default.
Cosa succede se scriviamo
Persona p = new Persona("Mario", "Rossi");?
- il primo codice che ho scritto funziona, perché il costruttore si aspetta due parametri di tipo stringa (i.e., il nome e il cognome) e noi glieli stiamo dando;
- nel secondo codice che ho scritto abbiamo un errore in fase di compilazione, perché non c'è nessun costruttore che si aspetta questi due parametri.
Cosa succede se scriviamo
Persona p = new Persona();?
- nel primo codice che ho scritto abbiamo un errore in fase di compilazione, perché non esiste nessun costruttore che si aspetta zero parametri;
- il secondo codice che ho scritto funziona, perché java ha inserito il costruttore di default che effettivamente che è definito con zero parametri.
Cosa facciamo se vogliamo fare entrambe le cose? Scriviamo due costruttori
Java:
public class Persona {
private String nome;
private String cognome;
public Persona() { /* costruttore vuoto */ }
public Persona(String nome, String cognome) {
this.nome = nome;
this.cognome = cognome;
}
}
La mia obiezione precedente dovrebbe farti capire per quale motivo java non scrive un costruttore di default se il programmatore ne ha esplicitamente scritto uno: questo meccanismo esiste perché certi oggetti (e.g., una persona senza nome) sono completamente illogici e non dovrebbero mai esistere. Nella programmazione object-oriented vogliamo mantenere uno stato consistente, quindi se non ha senso avere una persona senza nome allora non ti do nemmeno la possibilità di crearla. È un meccanismo di sicurezza, un po' come public e private: non mettiamo tutto public (anzi, usiamo private il più possibile!), complicandoci la vita, per prevenire errori. Non mi metto a spiegare getter/setter e public/private visto che nessuno me l'ha chiesto, ma quanto ho scritto dovrebbe chiarire il tuo dubbio iniziale. Altrimenti boh... facci capire cosa non hai capito e vediamo se riusciamo a chiarirti il dubbio.
Non ci biasimare se ogni tanto ti facciamo notare che il tuo contributo alla community self-centered e la quasi totalità dei tuoi post suona come
do my homework asap... anche considerando reposti su più forum come per massimizzare il profitto. Non sei obbligata a partecipare alla community così come noi non siamo obbligati a risponderti. Quando rispondiamo, lo facciamo volentieri
chiaro che è più piacevole dare una spiegazione discutere su quella piuttosto che risolvere gli errori.
