Ik heb een voorbeeld programmaatje geschreven, hopelijk is commentaar in de code voldoende...
Het doet niets bijzonders. Het berekent de getallen van fibonacci. Je geeft op hoeveel getallen je wilt hebben en dan wordt een array aangemaakt met de getallen.
Het gebruikt beide manieren om een object op te slaan.
Serialization is het eenvoudigst, JAVA neemt alle variabelen uit je klasse en zet ze in bestand,
Bij het terug lezen worden alle variable weer ingelezen en je object is weer klaar voor gebruik.
Dit is vooral bedoeld voor tijdelijk opslaan van je objecten. (Als het aantal variabele in je klasse wijzigt zijn je bestanden onbruikbaar geworden..)
XMLEncode/Decoder is veel ingewikkelder. Java zoekt uit hoe jou object is aangemaakt en slaat dit op.
Er wordt gekeken naar welke functies (dus niet variabelen!) in je klasse werden aangeroepen.( vandaar dat je naamgeving belangrijk wordt.!)
Omdat functie niet snel zullen wijzigen is dit bedoelt voor "long term" opslag.. Verder is bestand well formated XML. zodat zeer geschikt is om over het internet te versturen.
Als je ooit netwerk spelletjes gaat schrijven is dit "the way to go"
Ik zal zeker beginnen met "serialization" en niet zelf array gaan opslaan en inlezen (dit is zeker mogelijk en ook nog eevoudig Maar als je meer variabele gaat opslaan gaat dit niet meer lukken).
succes...
ps. de try catch constructie zijn niet 100% ok.. maar wel lekker kort...
Code:
package saveclassdemo;
import java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
FibonacciReeks reeks = new FibonacciReeks();
reeks.setAantal(10); // maak lijst van 10 getallen..
System.out.println(reeks.toString());
//save reeks using serialization.
System.out.println("saving using serialization");
try {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("fibronacci.dat"));
oos.writeObject(reeks);
oos.close();
} catch (IOException ex) {
ex.printStackTrace();
}
//create new reeks
System.out.println("create new reeks");
reeks.setAantal(5);
System.out.println(reeks.toString());
//load old reeks
System.out.println("load old reeks");
try {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("fibronacci.dat"));
//readObject geeft een object terug we moeten de compiler vertellen dat het een Fibonacci reeks was vandaar de cast.
reeks = (FibonacciReeks) ois.readObject();
ois.close();
} catch (Exception ex) {
ex.printStackTrace();
}
System.out.println(reeks.toString());
// nu nog eens, save via long term persistence.
System.out.println("saving usign persistence");
try {
XMLEncoder xe = new XMLEncoder(new BufferedOutputStream(new FileOutputStream("fibronacci.xml")));
xe.writeObject(reeks);
xe.close();
} catch (IOException ex) {
ex.printStackTrace();
}
//create new reeks
System.out.println("create new reeks");
reeks.setAantal(20);
System.out.println(reeks.toString());
//load old reeks
System.out.println("load old reeks");
try {
XMLDecoder xd = new XMLDecoder(new BufferedInputStream(new FileInputStream("fibronacci.xml")));
//readObject geeft een object terug we moeten de compiler vertellen dat het een Fibonacci reeks was vandaar de cast.
reeks = (FibonacciReeks) xd.readObject();
xd.close();
} catch (Exception ex) {
ex.printStackTrace();
}
System.out.println(reeks.toString());
}
}
Code:
import java.io.Serializable;
// Als je xmlencoder/xmldecoder will gebruiken moet je zorgen dat je klasse voldoet aan de "bean" naamgeving.
// in het kort betekent dit. Dat je variabelen private zijn en getter/setter gebruikt om je variabele te veranderen.
// variable getallen -> getGetallen & setGetallen (let op hoofdletters!)
//
// Voor serialization is dit allemaal niet nodig dan is het belangrijk dat je "implements Serializable" aan je klasse toevoegt.
public class FibonacciReeks implements Serializable {
private int[] getallen;
public FibonacciReeks() {
}
public int[] getGetallen() {
return getallen;
}
public void setGetallen(int[] getallen) {
this.getallen = getallen;
}
//maakt de fibonacci reeks aan. aantal bepaald de lengte van de array.
public void setAantal(int aantal) {
if (aantal < 1) {
throw new IllegalArgumentException("Value should be larger than 0");
}
getallen = new int[aantal];
getallen[0]=0;
if (aantal==1) {
return;
}
getallen[1]=1;
for (int i = 2 ; i < aantal ; i++) {
getallen[i] = getallen[i-2] + getallen[i-1];
}
}
//hoewel er geen variable aantal is doen we net alsof...
public int getAantal() {
return getallen == null ? 0 : getallen.length;
}
//print de array
public String toString() {
if (getallen==null || getallen.length==0) {
return "Empty";
}
StringBuilder sb = new StringBuilder("" + getallen[0]);
for (int i=1 ; i < getallen.length ;i++) {
sb.append(',');
sb.append(getallen[i]);
}
return sb.toString();
}
}
"Dé grootste en gratis computerhelpdesk van Nederland"
