Serialisieren

F

feiste

Bekanntes Mitglied
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:

Java: 
 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());
     }
   }
 }

Java: 
 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());
     }
     
     
   }
 }

Java: 
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 !
 
Zuletzt bearbeitet:
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.
 
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?
 
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. ^^
 
Java: 
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.
 
Volvagia hat gesagt.:
Java: 
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.
Zum Vergrößern anklicken....

Name wäre in dem fall die variable oder?

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

Java: 
private String name;
//
public String getName()
{
	return(name);
}
 
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


Java: 
 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());
     }
     
     
   }
 }
 
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.
 
so? =)

Java: 
 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? 🙂
 
aber jetzt passts oder? 🙂

Java: 
 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);
}
   
   
   
 }
 
durch das

Java: 
GameWindow gw = new GameWindow();

dann ladet der doch die komplette Klasse GameWindow
oder nicht?
 
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.
 
Zuletzt bearbeitet von einem Moderator:
@ raiL

sorry habe " double " vergessen!

Java: 
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.
Zum Vergrößern anklicken....

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.
Zum Vergrößern anklicken....

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?
Zum Vergrößern anklicken....
 
Zuletzt bearbeitet:
Ein kleines Beispiel:


Java: 
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();
	}
	
}
 
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??
 
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
 
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:

Java: 
if(gameover == true)
{ new EINLESEN(); }
oder?
 
"Richtig" und gut sieht anders aus, aber es ist das was du anscheinend willst

Java: 
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);
	}
	
}
 
vielen Dank !! =)
werds gleich ausprobieren 🙂


für was ist denn das:
Java: 
package de.test;
?

ich denk mal das ist für mich nicht relevant,
da ich bluej verwende?
 
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
 
habe deine beiden klassen verwendet
und diese beiden:

Java: 
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);
        
    }
}

Java: 
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
 
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 :/
 
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
 
danke das geht jetzt 🙂

aber kanns sein, dass der Befehl

new ser();
bzw
new deser();

zum serialisieren/deserialisieren falsch ist ?
wegn der main methode..
 
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.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Serialisieren von Class<?>
Antworten: 2
Mehrere Objekte verschlüsselt serialisieren
Antworten: 6
Serialisieren, aber wie?
Antworten: 3
Objekt serialisieren/deserialisieren und in einer SQLite-Datenbank speichern
Antworten: 3
Datum serialisieren
Antworten: 1

Zurück
Oben