Serialisieren

[feiste]

Hallo,

ich versuche gerade 2 statische variablen
double punkte
und
String name

zu serialisieren und wieder deserialisieren
und dannach mit den beiden Variablen weiter zu arbeiten.
Nur leider bekomm ich das nicht ganz auf die reihe :/

Hier mal meine Ansätze:

 import java.io.*;
 import java.util.*;
 
 public class AUSLESEN
 {
   public static void main(String[] args) throws Exception
   {
     try {
     FileOutputStream fs = new FileOutputStream("test.ser");
       ObjectOutputStream os = new ObjectOutputStream(fs);
      
      os.writeDouble(SPIEL.punkte2);
      os.writeObject(GAMEWINDOW.name);
       os.close();
    } catch (IOException e) {
       System.err.println(e.toString());
     }
   }
 }

 import java.io.*;
 import java.util.*;
 
 public class EINLESEN
 { 
     public static double punkte3;
   
     public static void main(String[] args) throws Exception
   {
     try {
       FileInputStream fs = new FileInputStream("test.ser");
       ObjectInputStream os = new ObjectInputStream(fs);
     

	punkte3 = os.readDouble();
	String name = (String) os.readObject();
	System.out.println(punkte2);
	

	os.close();
     } catch (ClassNotFoundException e) {
       System.err.println(e.toString());
     } catch (IOException e) {
       System.err.println(e.toString());
     }
     
     
   }
 }

import java.io.Serializable;

public class SPIEL implements Serializable
{
public static punkte2;

public SPIEL()
{ ...... }
}

darf man statische variablen überhaupt serialisieren?
Und wie kann ich den Variablen der Klasse A
und sie statisch zu machen
in der Klasse B verwenden?

Danke !

 

[nrg]

darf man statische variablen überhaupt serialisieren?

dürfen schon aber es funktioniert nicht (edit: was meinst du wohl, warum das ding ObjectOutputStream heisst?)

 

[Volvagia]

Nein. Weißt du eigendlich, was statisch bedeutet? (In Java)
Ich habe mal gelesen, dass es eventuell einen Weg gibt, hab das aber nicht weiter verfolgt.

 

[feiste]

achso deshalb funktioniert das nicht
aber sonst ist der code zum serialisieren in ordnung?

wie kann ich den dann, die variable x von der Klasse A
in der Klasse B verwenden
ohne sie statisch zu machen?

 

[Volvagia]

Du erzeugst Instanzen mit new. Das sollte man sowieso fast immer machen, eine statische Methode macht nur selten Sinn, eigendlich sind fast immer nur Konstante statisch. ^^

 

[feiste]

Du erzeugst Instanzen mit new. Das sollte man sowieso fast immer machen, eine statische Methode macht nur selten Sinn, eigendlich sind fast immer nur Konstante statisch. ^^

könntest du mal bitte ein Beispiel machen?

 

[Volvagia]

GameWindow gw = new GameWindow(); //Klassennamen bitte CamelCase.
gw.getName();

2 Dinge zum Code noch:
1. Wäre ein finally zum Schließen des Streams sauberer,
2. Gibt dir die toString-Methode bloß den Text und die Klasse der Exception zurück. Benutz lieber printStackTrace(), damit erhältst du die Zeilennummer und den Stack (Methodenaufrufe), sonst weißt du nicht, wo die Exception geflogen ist.

 

[feiste]

GameWindow gw = new GameWindow(); //Klassennamen bitte CamelCase.
gw.getName();

2 Dinge zum Code noch:
1. Wäre ein finally zum Schließen des Streams sauberer,
2. Gibt dir die toString-Methode bloß den Text und die Klasse der Exception zurück. Benutz lieber printStackTrace(), damit erhältst du die Zeilennummer und den Stack (Methodenaufrufe), sonst weißt du nicht, wo die Exception geflogen ist.

Name wäre in dem fall die variable oder?

okay danke !

 

[Volvagia]

Du musst natürlich den Getter selbst noch in GameWindow schreiben:

private String name;
//
public String getName()
{
	return(name);
}

 

[feiste]

ok danke das funktioniert jetzt

aber wenn ich jetzt punkte3 in einer anderen Klasse weiterarbeiten will
ich mach ich dann das?

Fehlermeldung:
non static variable punkte3 cannot be referenced from a static context

 import java.io.*;
 import java.util.*;
 
 public class EINLESEN
 { 
     private double punkte3;
   
     public static void main(String[] args) throws Exception
   {
     try {
       FileInputStream fs = new FileInputStream("test.ser");
       ObjectInputStream os = new ObjectInputStream(fs);
     
 
    punkte3 = os.readDouble();
    String name = (String) os.readObject();
    System.out.println(punkte2);
    
 
    os.close();
     } catch (ClassNotFoundException e) {
       System.err.println(e.toString());
     } catch (IOException e) {
       System.err.println(e.toString());
     }
     
     
   }
 }

 

[Volvagia]

Statische Methoden können natürlich nur auf statische Variablen zugreifen. Am Besten, du erzeugst eine Instanz von EINLESEN, und lässt ihm die Arbeit im Konstruktor erledigen.

 

[feiste]

so? =)

 import java.io.*;
 import java.util.*;
 
 public class EINLESEN
 { 
    private double punkte3;
    ObjectInputStream os;
     public EINLESEN() throws Exception
   { 
     try {
       FileInputStream fs = new FileInputStream("test.ser");
       os = new ObjectInputStream(fs);
     
    punkte3 = os.readDouble();
	String name = (String) os.readObject();
	
	

	//os.close();
     } catch (ClassNotFoundException e) {
       System.err.println(e.toString());
     } catch (IOException e) {
       System.err.println(e.toString());
     }
     finally
     { os.close(); }
     
     
   }
   
   public double getPunkte3()
{
    return(punkte3);
}
   
   
   
 }

achso ist das mit dem finally jetzt richtig?

 

[Volvagia]

Ja, aber natürlich brauchst du noch die Main, die eine Instanz erzeugt.

 

[feiste]

aber jetzt passts oder?

 import java.io.*;
 import java.util.*;
 
 public class EINLESEN
 { 
    private double punkte3;
    ObjectInputStream os;
     public EINLESEN() throws Exception
   { 
     try {
       FileInputStream fs = new FileInputStream("test.ser");
       os = new ObjectInputStream(fs);
     
    punkte3 = os.readDouble();
	String name = (String) os.readObject();
	
	

	//os.close();
     } catch (ClassNotFoundException e) {
       System.err.println(e.toString());
     } catch (IOException e) {
       System.err.println(e.toString());
     }
     finally
     { os.close(); }
     
     
   }
   
    public static void main(String[] args) throws Exception
    { new EINLESEN(); }
   
   public double getPunkte3()
{
    return(punkte3);
}
   
   
   
 }

 

[feiste]

durch das

GameWindow gw = new GameWindow();

dann ladet der doch die komplette Klasse GameWindow
oder nicht?

 

[Gelöschtes Mitglied 5909]

So ein blödsinn was ihr da schreibt. Natürlich kann man statische Variablen Serialisieren, denn auch die sind Objekte.
Auch primitive Datentypen haben ihr Wrapper Objekte.

Ob es sinn macht und das ist was der TO will ist was anderes.

Und oben Serialisiert auch nur die Variable und nicht die Klasse die die statische Variable enthält, was ggf. sogar sinn machen kann.

Was absolut keinen sinn macht ist eine klasse die nur aus statischen Variablen besteht zu serialisieren.

Da er aber oben keinen typ für punkt2 stehn hat ist das schwierig herauszufinden.

 

[feiste]

@ raiL

sorry habe " double " vergessen!

import java.io.Serializable;
 
public class SPIEL implements Serializable
{
public static double punkte2;
 
public SPIEL()
{ ...... }
}

Ob es sinn macht und das ist was der TO will ist was anderes.

Wann macht es denn Sinn statische Variablen zu serialisieren?

Und oben Serialisiert auch nur die Variable und nicht die Klasse die die statische Variable enthält, was ggf. sogar sinn machen kann.

Ich möchte nicht die komplette Klasse serialisieren sondern nur die variable !


Frage:

durch das



GameWindow gw = new GameWindow();


dann ladet der doch die komplette Klasse GameWindow
oder nicht?

 

[feiste]

müsste es, wenn möglich heute abend noch fertig bekommen!
Aber, wenn nicht ists auch nicht so schlimm.

 

[Gelöschtes Mitglied 5909]

Ein kleines Beispiel:

package de.test;

import static org.junit.Assert.assertEquals;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

import org.apache.commons.io.IOUtils;
import org.junit.Test;

public class SterialisationTestCase {

	public static class Holder implements Serializable {
		private static final long serialVersionUID = 1L;
		public static String foo = "foo";
	}

	@Test
	public void test1() throws Exception, IOException {

		File file = File.createTempFile("test", ".ser");
		ObjectOutputStream out = null;
		try {
			out = new ObjectOutputStream(new FileOutputStream(file));
			out.writeObject(Holder.foo);
		} finally {
			IOUtils.closeQuietly(out);
		}

		String actual;
		ObjectInputStream in = null;
		try {
			in = new ObjectInputStream(new FileInputStream(file));
			actual = (String) in.readObject();
		} finally {
			IOUtils.closeQuietly(in);
		}
		assertEquals(Holder.foo, actual);
		
		file.delete();
	}
	
}

 

[feiste]

danke !! =)
habe dazu aber noch ein paar Fragen:

1. seh ich das richtig
du schreibst alles in eine Methode ?
wie soll man denn dann dem Programm sagen,
wann es die Variable abspeichern soll
und wann es die Variable wieder deserialisieren soll?

2. für was steht den das "Holder" ?


3. Steht der befehl "file.delete();" dafür die gespeicherte Datei wieder zu löschen?
Wenn ja, wieso machst du das??

 

[Gelöschtes Mitglied 5909]

Das ist ein TestCase um dir zu zeigen dass das funktioniert

Es ist keinesfals gedacht, dass das später in einem "Programm" auftaucht.

Holder ist eine Klasse mit einer statischen Variablen. Siehe Zeile 18 bis 21

 

[feiste]

komme mit dem Beispiel leider nicht klar :/

wäre es möglich dass du mir so ein Beispiel machst?

man hat z.B eine statische Variable double x aus der Klasse A
=> A.x

diese will ich jetzt in der Klasse " EINLESEN " serialisieren
und dannach wieder in der Klasse " AUSLESEN " deserialisieren.

wäre das zuviel verlangt von dir?

______________________________

Angenommen ich will die Variable serialisieren, wenn gameover == true
würde das so doch so aussehen:

if(gameover == true)
{ new EINLESEN(); }

oder?

 

[Gelöschtes Mitglied 5909]

"Richtig" und gut sieht anders aus, aber es ist das was du anscheinend willst

package de.test;

public class A {

	public static double x = 1.0d;
	
}


package de.test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Einlesen {

	public static void speichern(File file, Object object) throws IOException {
		ObjectOutputStream out = null;
		try {
			out = new ObjectOutputStream(new FileOutputStream(file));
			out.writeObject(object);
		} finally {
			if (out != null) {
				try {
					out.close();
				} catch (IOException e) {
					// ignore
				}
			}
		}
	}
	
}

package de.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Auslesen {

	public static Object laden(File file) throws IOException {
		ObjectInputStream in = null;
		try {
			in = new ObjectInputStream(new FileInputStream(file));
			return in.readObject();
		} catch (Exception e) {
			throw new IOException(e);
		} finally {
			if (in != null) {
				try {
					in.close();
				} catch (IOException e) {
					// ignore
				}
			}
		}
	}
	
}

package de.test;

import java.io.File;
import java.io.IOException;

public class Main {

	public static void main(String[] args) throws IOException {
		File file = File.createTempFile("foo", ".ser");
		Einlesen.speichern(file, A.x);
		
		A.x = (Double) Auslesen.laden(file);
	}
	
}

 

[feiste]

vielen Dank !! =)
werds gleich ausprobieren


für was ist denn das:

package de.test;

?

ich denk mal das ist für mich nicht relevant,
da ich bluej verwende?

 

[Gelöschtes Mitglied 5909]

Das nennt sich package (wie da schon steht) und dient der "Gruppiernung" von Klassen.

Man stelle sich vor es existieren zwei Klassen "Einlesen" - was nu?

Für dich wird es nicht relevant sein

 

[feiste]

habe deine beiden klassen verwendet
und diese beiden:

import java.io.File;
import java.io.IOException;
public class deser
{ public static double highscore;
    public static void main(String[] args) throws IOException {
        File file = File.createTempFile("foo", ".ser");
        /
        
        highscore = (Double) Auslesen.laden(file);
        
    }
}

import java.io.File;
import java.io.IOException;

public class ser
{
    
    public static void main(String[] args) throws IOException {
        File file = File.createTempFile("foo", ".ser");
        Einlesen.speichern(file, SPIEL.punkte2);
        
      
    }
   

    
}

aber ich bekomm immer diese meldung:

java.io.IOException:
java.io.EOFException

 

[feiste]

des kann doch ned so schwer sein,
dass ich es schaff eine statische double variable
abzuspeichern damit ich seh beim start
wieder als Highscore anzeigen lassn kann^^
ich schaffs einfach nicht :/

 

[Gelöschtes Mitglied 5909]

Du musst halt erst mal was speichern damit du es wieder laden kannst

 

[feiste]

Du musst halt erst mal was speichern damit du es wieder laden kannst

das mit dem speichern mach ich doch in der klasse "ser"
diese habe ich zuerst ausgeführt.
dannach die klasse "deser"

 

[Gelöschtes Mitglied 5909]

Du weißt aber dass createTempFile eine temporäre datei erzeugt, die jedesmal eine andere ist?

mach mal File file = new File("C:/foo.ser"); bei beiden

 

[feiste]

danke das geht jetzt

aber kanns sein, dass der Befehl

new ser();
bzw
new deser();

zum serialisieren/deserialisieren falsch ist ?
wegn der main methode..

 

[Gelöschtes Mitglied 5909]

ja, mit new erzeugst du ein neues objekt. Und da du außer der statischen main methode nix drinnen hast passiert auch nix.

Die Main methode ist im übrigen der EInstiegspunkt eines Programmes. Dir scheint es echt an Grundlegendem zu fehlen.

Ich empfehle dir dringend ein Buch zu lesen, ansonsten wird das nix.

 

[feiste]

ja werd ich auch machen !
hab jetztnachgelesen so gehts =)

ser.main(new String[] {"args"}) ;

 

[feiste]

wie kann ich den in die eine Datei ("foo.ser")
2 Variablen ( String und double ) speichern
bzw. laden ?

 

[Volvagia]

OOS besitzen die Methode writeDouble.
Ansonst kannst du sie natürlich noch zu Strings und wieder zurückparsen.

 

[Andi_CH]

ja werd ich auch machen !
hab jetzt nachgelesen so gehts =)

ser.main(new String[] {"args"}) ;

Wo steht denn so ein Schei... ???:L

Es wurde zwar schon gesaagt, aber vielleicht hilft eine Wiederholung:
Eine Prozedur namens main die nicht wirklich ein Hauptprogramm ist, ist eine Designfehler!