Mi sembra di capire che sei un autodidatta della programazione Java: molto bene, è il modo migliore per imparare (secondo me)!
Solo che a volte l'aiuto di chi le cose le sa già è importante, se non indispensabile... per questo esistono dei corsi che insegnano (più o meno bene) la programmazione.
Se vuoi possiamo parlare di questa serializzazione, cercando di riassumere i concetti più importanti il più semplicemente possibile.
Cominciamo con un esempio, semplice semplice, di ciò che accade quando non si è in possesso di questo potente strumento: consideriamo di avere una applicazione che necessita di dati strutturati. Ad esempio, dobbiamo gestire una semplice biblioteca.
La biblioteca prevede, ovviamente, di mantenere delle informazioni relative ai libri e per questo viene, generalmente, creata una classe che rappresenta proprio il libro. Una classe Libro, molto semplice, può essere la seguente:
codice:
public class Libro {
private String titolo; // Il titolo del libro
private String autore; // L'autore del libro
private int annoPubblicazione; // L'anno di prima pubblicazione
public Libro(String titolo, String autore, int annoPubblicazione) {
this.titolo = titolo;
this.autore = autore;
this.annoPubblicazione = annoPubblicazione;
}
public String getTitolo() { return titolo; }
public String getAutore() { return autore; }
public String getAnnoPubblicazione() { return annoPubblicazione; }
}
Questa classe, semplicissima, si usa in modo altrettanto semplice: si costruisce un oggetto Libro a partire dai dati essenziali richiesti dal costruttore:
codice:
String titolo = "Java, mattone dopo mattone";
String autore = "Massimiliano Tarquini";
int anno = 2001;
Libro lib = new Libro(titolo, autore, anno);
Ora supponiamo di dover salvare le informazioni riguardanti questo libro in un file (vediamo le cose in grande: la biblioteca avrà moltissimi libri da salvare su file!). Come possiamo fare? La cosa più ovvia e semplice è quella di creare un file di testo che contenga tutte le informazioni, magari ben formattate... qualcosa del genere, insomma:
codice:
Titolo libro Autore Anno Pubblicazione
----------------------------------------------------------------------------------
Java, mattone dopo mattone Massimiliano Tarquini 2001
... ... ...
Bene... tutto questo ha i suoi vantaggi: abbiamo un bel file con tutte le informazioni che ci servono. Quand'è che sorgono i problemi? I problemi sorgono quando dobbiamo recuperare questi dati dal file: per poter ripopolare la nostra lista di oggetti Libro, dobbiamo leggere ciascuna riga del file, spezzettarla in base all'informazione che ci serve (Titolo, Autore e Anno) e poi ricreare un oggetto, passando queste tre informazioni al costruttore dell'oggetto.
Non che sia un problema, ma a lungo andare potrebbe essere fastidiosa la cosa (soprattutto se abbiamo a che fare con molti campi da popolare).
Per questo entra in soccorso la serializzazione: con questo strumento non dobbiamo più preoccuparci di recuperare ciascuna informazione singola dall'oggetto, salvarla sul file e, per contro, quando dovremo ricreare gli oggetti, non dovremo più andarci a pescare ciascuna informazione da passare al costruttore. Possiamo, semplicemente, salvare l'oggetto sul file. In questo modo, quando poi andremo a leggere il file, dovremo solo leggere gli oggetti salvati.
Vediamo come si fa: è necessaio far implementare l'interfaccia Serializable alla classe che verrà salvata sul file. Tale interfaccia non presuppone l'implementazione di nessun metodo:
codice:
public class Libro implements Serializable {
private String titolo; // Il titolo del libro
private String autore; // L'autore del libro
private int annoPubblicazione; // L'anno di prima pubblicazione
public Libro(String titolo, String autore, int annoPubblicazione) {
this.titolo = titolo;
this.autore = autore;
this.annoPubblicazione = annoPubblicazione;
}
public String getTitolo() { return titolo; }
public String getAutore() { return autore; }
public String getAnnoPubblicazione() { return annoPubblicazione; }
}
Come vedi la classe non è stata toccata di una virgola, però ora non dovremo più andarci a salvare tutti i suoi campi, è sufficiente salvare sul file l'oggetto lib creato in precedenza:
codice:
String titolo = "Java, mattone dopo mattone";
String autore = "Massimiliano Tarquini";
int anno = 2001;
Libro lib = new Libro(titolo, autore, anno);
ObjectOutputStream oos = new ObjectOutputStream( new FileOutputStream("mioFile.dat") );
oos.writeObject(lib);
oos.close();
A questo punto, quando dovremo ricreare tutti i libri salvati, sarà sufficiente leggere gli oggetti dal file:
codice:
ObjectInputStream ois = new ObjectInputStream( new FileInputStream("mioFile.dat") );
Libro lib = (Libro) ois.readObject();
Non abbiamo dovuto leggere tre informazioni per ricreare l'oggetto: abbiamo letto solo l'oggetto.
Questo post non deve essere inteso come tutto ciò che la serializzazione permette di fare, sarebbe troppo riduttivo! E' solo un esempio di quanto aiuta tale strumento.
Spero, per lo meno, di averti dati delle informazioni importanti su quali sono i vantaggi nell'utilizzo di questo strumento, piuttosto che la normale procedura di salvataggio di informazioni.
Ciao.