Mrz 31

collections und Arrays lassen sich auf die gleiche Art und Weise serialisieren wie Objekte;

Definitionen:

ArrayList <String> a= new ArrayList <String>();
a.add(“Hello “);
a.add(“World “);
a.add(“serialized “);

int [] b = {1,2,3};

Wegschreiben mit ObjectOutputStream:

os.writeObject(a);
os.writeObject(b);

De-Serialisierung mit ObjectInputStream:

a=(ArrayList) ois.readObject();
b=(int[]) ois.readObject();

Auch hier ist zu beachten,dass jedes einzelne Element serialisiert werden muss. Ausnahmen führen zu einem Laufzeitfehler (NotSerializableException).  Zu beachten ist auch, das das Collection-Interface selbst nicht serialisierbar ist, die konkrete Klasse aber schon.

Tagged with:
Mrz 29

Diesmal ändern wir den Code so ab, dass nicht der Default-Konstruktor, sondern ein überladener Konstruktor aufgerufen wird:

import java.io.*;
import java.util.*;

class Angestellter {

int PersNr;

public Angestellter (int PersNr){

this.PersNr=PersNr;

}

public static void main(String args[]) {

Buchhalter b = new Buchhalter(10000, 234);
System.out.println(“Vor Serialisierung: Dispositionsrahmen: “+b.Dispositionsrahmen+” PersNr “+b.PersNr);

try{

FileOutputStream fos = new FileOutputStream(“Angestellter.ser”);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(b);
oos.flush();
oos.close();

}catch (IOException e){ e.printStackTrace(); }

try {

FileInputStream fis = new FileInputStream(“Angestellter.ser”);
ObjectInputStream ois = new ObjectInputStream(fis);
b=(Buchhalter) ois.readObject();

}catch (IOException e) {e.printStackTrace();}
catch (ClassNotFoundException e){e.printStackTrace();}

System.out.println(“Nach De-Serialisierung: Dispositionsrahmen: “+b.Dispositionsrahmen+” PersNr “+b.PersNr);

}

}

class Buchhalter extends Angestellter implements Serializable {

int Dispositionsrahmen;

public Buchhalter (int Dispositionsrahmen, int PersNr){

super(PersNr);

this.Dispositionsrahmen=Dispositionsrahmen;
//this.PersNr=PersNr;

}

}

Da auch der Konstruktor nicht serialisiert und somit nicht vorhanden ist, kann das Objekt nicht de-serialisiert werden; es wird eine InvalidClassException zur Laufzeit ausgegeben.

Tagged with:
Mrz 27

Wenn die Oberklasse serialisiert ist, sind automatisch alle davon abgeleiteten Klassen auch serialisiert. Bis hierhin noch relativ logisch, aber was passiert, wenn nur die Unterklasse serialisiert wird?

Fangen wir mal mit einem ersten Beispiel an:

import java.io.*;
import java.util.*;

class Angestellter  {

int PersNr;

public static void main(String args[]) {

Buchhalter b = new Buchhalter(10000, 234);
System.out.println(“Vor Serialisierung: Dispositionsrahmen: “+b.Dispositionsrahmen+” PersNr “+b.PersNr);

try{

FileOutputStream fos = new FileOutputStream(“Angestellter.ser”);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(b);
oos.flush();
oos.close();

}catch (IOException e){ e.printStackTrace(); }

try {

FileInputStream fis = new FileInputStream(“Angestellter.ser”);
ObjectInputStream ois = new ObjectInputStream(fis);
b=(Buchhalter) ois.readObject();

}catch (IOException e) {e.printStackTrace();}
catch (ClassNotFoundException e){e.printStackTrace();}

System.out.println(“Nach De-Serialisierung: Dispositionsrahmen: “+b.Dispositionsrahmen+” PersNr “+b.PersNr);

}

}

class Buchhalter extends Angestellter implements Serializable {

int Dispositionsrahmen;

public Buchhalter (int Dispositionsrahmen, int PersNr){

this.Dispositionsrahmen=Dispositionsrahmen;
this.PersNr=PersNr;

}

}
Da hier nur die Unterklasse weggeschrieben wird, fehlen beim De-Serialisieren sämtliche Informationen über die Oberklasse.

Die Ausgabe lautet deswegen:

Vor Serialisierung: Dispositionsrahmen: 10000 PersNr 234
Nach De-Serialisierung: Dispositionsrahmen: 10000 PersNr 0

Da die Personalnummer nicht mit weggeschrieben wird (sie gehört ja zur nicht-serialisierten Klasse Angestellter) wird hier der Default-Wert 0 (wir erinnern uns; Variablen, die auf dem Klassen-Level initialisiert werden, bekommen einen Default-Wert)  gezogen.

Selbstverständlich gibt es auch hier wieder die Möglichkeit, diesem Problem mit der Überschreibung von ReadObject/ WriteObject entgegen zu wirken.

Tagged with:
Mrz 25

Wie Ihr Euch bestimmt schon denken könnt, gibt es eine Lösung für das Problem der NullPointerExceptions bei transienten Variablen/ Objekten. Es werden die Methoden readObject/ writeObjekt so überschrieben, dass zwar nicht das Objekt mitserialisiert wird, aber die Werte die zur Anlage eines neuen Objektes benötigt werden:

Der Einfachheit halber habe ich unser Beispiel ein bisschen angepasst, so dass zur Anlage von Auto kein Objekt (String), sondern ein primitiver Datentyp benötigt wird. Ich beziehe mich im folgenden nur auf Änderungen, bezüglich (De-)Serialisierung.
import java.io.*; // Definitionen wie gehabt, keine Veränderung.

class Angestellter implements Serializable {

public static void main(String args[]) {

Auto auto = new Auto (345);
Manager manager = new Manager(“Finanzen”, auto);

try {

FileOutputStream fos = new FileOutputStream(“Manager.ser”);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(manager);
oos.flush();
oos.close();

}catch (IOException e){ e.printStackTrace(); }

try {

FileInputStream fis = new FileInputStream(“Manager.ser”);
ObjectInputStream ois = new ObjectInputStream(fis);
manager=(Manager) ois.readObject();

}catch (IOException e) { e.printStackTrace();}
catch (ClassNotFoundException e){e.printStackTrace();}

}

}

class Manager implements Serializable {

private void writeObject(ObjectOutputStream oos){ // Überschreibung der Methode writeObjekt, um die NullPointerException zu umgehen

try{

oos.defaultWriteObject(); // Wegschreiben des Objektes
oos.writeInt(auto.FahrzeugNr); // Zusätzliches Wegschreiben des int-Wertes, mit dem Auto angelegt wird

} catch (IOException e) { e.printStackTrace(); }

}

private void readObject (ObjectInputStream ois){c

try {

ois.defaultReadObject(); // Lesen des Objektes
auto = new Auto(ois.readInt()); //Lesen des weggeschriebenen int-Wert und gleichzeitige Anlage des Objektes Auto

} catch (IOException e){e.printStackTrace(); }
catch (ClassNotFoundException e){e.printStackTrace();}

}

String Bereich;
transient Auto auto;

Manager (String Bereich, Auto auto){

this.Bereich=Bereich;
this.auto=auto;

}

void getAuto() {System.out.println(auto.FahrzeugNr); }

}

class Auto implements Serializable { // Auch hier keine Veränderung des Codes bezüglich Serialisierung

int FahrzeugNr;

Auto (int FahrzeugNr){

this.FahrzeugNr=FahrzeugNr;

}

}

Mrz 23

Wie Ihr anhand der letzten Beispiele schon gemerkt habt, lassen sich relativ problemlos ineinander verschachtelte Objekte serialisieren…. und was macht man, wenn man die ganze Verschachtelung gar nicht mit-serialisieren möchte?

Hier gibt es natürlich auch eine Lösung; das Schlüsselwort heisst transient. Jede Variable/ jedes Objekt, mit diesem Wort “markiert” wird nicht serialisiert:

import java.io.*
class Angestellter {

public static void main(String args[]) {

Auto auto = new Auto (“Mercedes S-Klasse”);
Manager manager = new Manager(“Finanzen”, auto);

try{

FileOutputStream fos = new FileOutputStream(“Manager.ser”);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(manager);
oos.flush();
oos.close();

}catch (IOException e){ e.printStackTrace(); }

}

}

class Manager implements Serializable {

String Bereich;
transient Auto auto;
// Das Objekt Auto wird mit transient modifiziert und somit nicht serialisiert.

Manager (String Bereich, Auto auto){

this.Bereich=Bereich;
this.auto=auto;

}

}

class Auto implements Serializable {

String fahrzeug;
Auto (String fahrzeug){

this.fahrzeug=fahrzeug;

}

}

Auch hier ist leider nicht alles so einfach wie es scheint; die Nicht-Serialisierung von transienten Datentypen/ Objekten ist zwar relativ einfach, aber was passiert beim De-Serialisieren?

Dem Manager fehlt das Auto (weil nicht serialisiert). Somit wird beim De-Serialisieren für Auto ein Null-Pointer zurückgegeben in folge dessen das Programm einen LaufzeitFehler (NullPointerException) ausgibt.

Tagged with:
Mrz 22

Was ist der Output des folgenden Codes:

import java.io.*;

class Angestellter{

public static void main(String args[]) {

File ordner = new File(“Test_Ordner”);
ordner.mkdir();

File datei = new File(ordner, “Test.txt”);
try {

datei.createNewFile();

}catch (IOException e) { }

for (int i = 1; i<=3; i++){

System.out.println(“Durchgang “+i);
File neuerDateiName = new File(ordner, “neuer_name.txt”);
System.out.println(“Umbenennung der Datei: “+datei.renameTo(neuerDateiName));
File neuerOrdnerName= new File (“neuer_Test_Ordner”);
System.out.println(“Umbenennung des Ordners: “+ordner.renameTo(neuerOrdnerName));

}

}

}

Antwort/ answer

Tagged with:
Mrz 21

Wir wissen jetzt, dass bei Nicht-Serialisierung Laufzeit- statt CompilerFehler auftreten, aber wie / wo werden diese beseitigt?

Wir haben ja 3 Stellen zur Auswahl: die Klassen Angestellter, Manager und Auto.

Da Angestellter ja nur ausführt und sich selbst nicht serialisiert braucht dieser auch nicht das Interface Serializable zu implementieren. Auf der anderen Seite müssen sämtliche Klassen, die miteinander in Verbindung stehend serialisiert werden sollen, auch das dafür benötigte Interface implementieren:

import java.io.*
class Angestellter {

public static void main(String args[]) {

Auto auto = new Auto (“Mercedes S-Klasse”);
Manager manager = new Manager(“Finanzen”, auto);

try{

FileOutputStream fos = new FileOutputStream(“Manager.ser”);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(manager);
oos.flush();
oos.close();

}catch (IOException e){ e.printStackTrace(); }

}

}

class Manager implements Serializable {

String Bereich;
Auto auto;

Manager (String Bereich, Auto auto){

this.Bereich=Bereich;
this.auto=auto;

}

}

class Auto implements Serializable {

String fahrzeug;
Auto (String fahrzeug){

this.fahrzeug=fahrzeug;

}

}

Tagged with:
Mrz 19

zuerst einmal ist wichtig, im Zusammenhang mit der Serialisierung sehr selten CompilerFehler ausgegeben werden.

Schauen wir uns mal dieses Beispiel an:

import java.io.*
class Angestellter {

public static void main(String args[]) {

Auto auto = new Auto (“Mercedes S-Klasse”);
Manager manager = new Manager(“Finanzen”, auto);

try{

FileOutputStream fos = new FileOutputStream(“Manager.ser”);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(manager);
oos.flush();
oos.close();

}catch (IOException e){ e.printStackTrace(); }

}

}

class Manager  {

String Bereich;
Auto auto;

Manager (String Bereich, Auto auto){

this.Bereich=Bereich;
this.auto=auto;

}

}

class Auto{

String fahrzeug;
Auto (String fahrzeug){

this.fahrzeug=fahrzeug;

}

}

Unglaublich, dieser Code compiliert auch ohne die Implementierung einwandfrei! Da aber nicht sein kann was nicht spezifiziert wurde, tritt ein Laufzeitfehler  (java.io.NotSerializableException) auf.

Tagged with:
Mrz 18

Welche dieser Codezeilen compilieren (nicht) einwandfrei?

BufferedWriter a = new BufferedWriter(new File(“Test1.txt”));
BufferedWriter b = new BufferedWriter(new FileWriter(“Test2.txt”));
BufferedWriter c = new BufferedWriter(new PrintWriter(“Test3.txt”));
BufferedWriter d = new BufferedWriter(new BufferedWriter(c));

Antwort/ answer
Tagged with:
Mrz 17

Nachdem wir schon ein Objekt serialisiert haben, wollen wir diese Daten wieder auslesen:

Angestellter b = new Angestellter() ; // Anlage eines Objektes, in das ausgelesen werden soll
try { // Auch hier müssen die Exceptions abgefangen werden

FileInputStream InputStream_file = new FileInputStream(“OutputStream_file.ser”); // Bekanntmachung des Files, aus dem ausgelesen werden soll
ObjectInputStream InputStream_object = new ObjectInputStream(InputStream_file); // Erzeugung eines Objektes, mit dem ausgelesen wird.
b=(Angestellter)InputStream_object.readObject(); // De-Serialisierung; dem Angestellten b wird das ausgelesene Objekt zugewiesen

} catch (IOException e) { e.printStackTrace();}
catch (ClassNotFoundException e){ e.printStackTrace();}

Tagged with:
preload preload preload
http://www.wikio.de Blog Top Liste - by TopBlogs.de Blogverzeichnis - Blog Verzeichnis bloggerei.de Bloggeramt.de Software
Webbhotell Top Blogs