# Vektor-Grafik im XML-Format speichern



## Pasche (2. Sep 2004)

Wie kann ich am einfachsten einen Vektor in einer Datei speichern ? Am besten direkt in einer XML Datei. Bis jetzt habe ich immer nur Speichervorgänge für GIF oder JPEG Dateien gefunden :-(


----------



## foobar (2. Sep 2004)

Hier ist ein kleines Beispiel, bei dem ein Vector von Mitarbeiterobjekten in einer Xmldatei gespeichert wird:

```
package xmldemo;
import java.io.File;
import java.io.FileOutputStream;
import java.util.Iterator;
import java.util.Vector;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;

import org.w3c.dom.Node;
import org.w3c.dom.Text;



public class XMLOutDemo 
{
	private String filename;
	private Vector v_data;
	private Document doc;
	public XMLOutDemo()
	{
		this.v_data = this.get_dummy_data();
		this.filename  = "/home/steffen/xmlout.xml";
		this.doc   = this.get_new_document();
		this.build_document();
		this.save_document();
		System.out.println("fertig");
	}
	
	private void build_document()
	{
		
		Node no_adrverw    = this.doc.createElement("adressenverwaltung");
		
		
		Iterator it = this.v_data.iterator();
		while (it.hasNext())
		{
			Mitarbeiter mit = (Mitarbeiter)it.next();
			Node no_adresse = this.doc.createElement("adresse");
						
			Node no_vor     = this.doc.createElement("vorname");
			Text te_vor 	= this.doc.createTextNode(mit.getVorname());
			Node no_nach    = this.doc.createElement("nachname");
			Text te_nach 	= this.doc.createTextNode(mit.getNachname());
			Node no_url     = this.doc.createElement("urlaub");
			Text te_url 	= this.doc.createTextNode(mit.getUrlaub());
			Node no_abt     = this.doc.createElement("abteilung");
			Text te_abt 	= this.doc.createTextNode(mit.getAbteilung());
			Node no_bon     = this.doc.createElement("bonus");
			Text te_bon 	= this.doc.createTextNode(String.valueOf(mit.getBonus()));
			Node no_sta     = this.doc.createElement("status");
			Text te_sta 	= this.doc.createTextNode(mit.getStatus());
			Node no_geh     = this.doc.createElement("gehalt");
			Text te_geh 	= this.doc.createTextNode(mit.getGehalt());
			
			no_vor.appendChild(te_vor);
			no_nach.appendChild(te_nach);
			no_url.appendChild(te_url);
			no_abt.appendChild(te_abt);
			no_bon.appendChild(te_bon);
			no_sta.appendChild(te_sta);
			no_geh.appendChild(te_geh);
						
			no_adresse.appendChild(no_vor);
			no_adresse.appendChild(no_nach);
			no_adresse.appendChild(no_url);
			no_adresse.appendChild(no_abt);
			no_adresse.appendChild(no_bon);
			no_adresse.appendChild(no_sta);
			no_adresse.appendChild(no_geh);
			no_adrverw.appendChild(no_adresse);
		}
		
		this.doc.appendChild(no_adrverw);
	}
	
	private Vector get_dummy_data()
	{
		Vector vec = new Vector();
		vec.addElement(new Mitarbeiter("vorname 1","nachname 1"));
		vec.addElement(new Mitarbeiter("vorname 2","nachname 2"));
		vec.addElement(new Mitarbeiter("vorname 3","nachname 3"));
		return vec;
	}
	
	private Document get_new_document()
	{
		Document doc = null;
		try 
		{
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			DocumentBuilder builder  = factory.newDocumentBuilder();
			doc = builder.newDocument();
		} 
		catch (Exception e) {e.printStackTrace();}
		return doc;
	}
	
	private void save_document()
	{	
		try
		{
			Transformer transformer = TransformerFactory.newInstance().newTransformer();
			DOMSource        source = new DOMSource( this.doc );
			FileOutputStream os     = new FileOutputStream( new File(this.filename) );
			StreamResult     result = new StreamResult( os );
			transformer.transform( source, result );
		}
		catch(Exception e){}
	}

	public static void main(String[] args) 
	{
		new XMLOutDemo();	
	}
}
```


```
package xmldemo;
public class Mitarbeiter 
{
	private String vorname = "";
	private String nachname = "";
	private int mitarbeiter_nr;
	private String urlaub = "";
	private String abteilung = "";
	private float bonus = 0.0f;
	private String status = "";
	private String gehalt = "";
	
	public Mitarbeiter(String vorname , String nachname)
	{
		this.vorname = vorname;
		this.nachname = nachname;
	}
	
	public Mitarbeiter(float bonus , String nachname)
	{
		this.bonus 		  = bonus;
		this.nachname = nachname;
	}
	
	public Mitarbeiter()
	{
	}
	
	public String getAbteilung() {
		return abteilung;
	}

	public float getBonus() {
		return bonus;
	}

	public int getMitarbeiter_nr() {
		return mitarbeiter_nr;
	}

	public String getNachname() {
		return nachname;
	}

	public String getUrlaub() {
		return urlaub;
	}

	public String getVorname() {
		return vorname;
	}

	public void setAbteilung(String string) {
		abteilung = string;
	}

	public void setBonus(float f) {
		bonus = f;
	}

	public void setMitarbeiter_nr(int i) {
		mitarbeiter_nr = i;
	}

	public void setNachname(String string) {
		nachname = string;
	}

	public void setUrlaub(String string) {
		urlaub = string;
	}

	public void setVorname(String string) {
		vorname = string;
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String string) {
		status = string;
	}

	public String getGehalt() {
		return gehalt;
	}

	public void setGehalt(String s) {
		gehalt = s;
	}

	public String toString()
	{
		return "Class Mitarbeiter: vorname "+this.getVorname() + " nachname " + this.getNachname() + " bonus " + this.getBonus();
	}

}
```


----------



## P3AC3MAK3R (3. Sep 2004)

Willst Du jetzt einen Vector speichern oder eine Vektor-Grafik?  :?:


----------



## Pasche (4. Sep 2004)

Also ich habe ein gaaaanz tolles Malprogramm erstellt  :roll:  , bei dem alle gezeichneten Elemente in einem Vektor gespeichert werden. Jetzt möchte ich einfach nur eine Speichern / Laden Funktion einbauen, dass ein bereits gemaltes Bild wieder geladen werden kann. Eigentlich muss ich dann nur den Vektor speichern, oder liege ich da falsch ? 
Muss aber halt unbedingt im XML Format sein. Und damit komme ich nicht so klar


----------



## foobar (5. Sep 2004)

Guck dir den Code an den ich gepostet habe und lies die Dokumentation zu den der einzelnen Klassen. Anstatt einen Vector von Mitarbeiterobjekten zu speichern, arbeitest du eben mit einem Vector von Zeichenobjekten.


----------



## Pasche (5. Sep 2004)

Als Java Anfänger steige ich da ehrlich gesagt nicht durch. Das scheint mir irgendwie ein wenig zu umfangreich für meine Verhältnisse zu sein. 

Ich brauche doch ganz einfach nur Vektor speichern / Vektor laden  :cry:


----------



## Roar (5. Sep 2004)

ja, nur ist genau das was foobar geschrieben hat eine möglichkeit um einen vektor zu speichern in einer XML Datei. du musst halt nur anpassen dass anstatt Mitarbeiter deine objecte in den vektren gespeichert werden.


----------



## Pasche (5. Sep 2004)

ja ihr seid witzig. wie soll ich denn was anpassen, was ich überhaupt nicht verstehe ? :bahnhof:


----------



## Pasche (5. Sep 2004)

Wenn das Ganze nicht im XML Format sein müsste, gäbe es dann eine nicht so umfangreiche Möglichekeit den Vektor zu speichern und zu laden ?


----------



## Roar (5. Sep 2004)

1. wenn du uns nicht sagst was du nicht evrstehst könne nwir dir auch nix erklären...
2. höchstens per serialisierung (bäh)


----------



## Pasche (5. Sep 2004)

Ich kann das Beispiel nicht mal kompilieren. Mitarbeiter kann ich noch kompilieren, aber bei der anderen Klasse sagt er dann, dass er Mitarbeiter nicht kennt, obwohl es im gleichen Verzeichnis liegt. Keine Ahnung was das ist


----------



## Roar (5. Sep 2004)

hast du die package anweisung beachtet/ entfernt/ angepasst?


----------



## Pasche (5. Sep 2004)

ich hab jetzt erstmal die demo ans laufen bekommen. jetzt weiß ich allerdings nicht wie ich das in mein Programm einbauen soll. Ich habe ja nicht verschiedene Objekte der gleichen Klasse in dem Vektor gespeichert, sondern viele Objekte verschiedener Klassen. 

Da weiß ich nicht wie ich das unterbringen muss / soll / kann. hab jetzt meinen vektor mit den verschiedenen objekten....und nun ?


----------



## Roar (5. Sep 2004)

tja ich hoffe mal deine objekte leiten alle von einer oberklasse ab die entsprechende abstrakte methoden definiert, oder dass deine objekte alle ein interface implementieren welches entsprechende methoden defininiert.


----------



## Pasche (5. Sep 2004)

die klassen sehen in etwa so aus:


```
class Line implements Paintable
{
	int x, y, w, h;
	Color color;
	
	public Line( Color color, int x, int y, int w, int h )
	{
		this.color = color;
		this.x = x;
		this.y = y;
		this.w = w;
		this.h = h;
	}
	
	public void paint( Graphics g )
	{
	  	g.setColor( color );
	        g.drawLine( x, y, w, h );
	}
}
```

aber keine ahnung was ich damit anfangen soll :bahnhof:


----------



## foobar (5. Sep 2004)

Ich hab deine Klasse mal etwas erweitert. Alles was du jetzt noch machen mußt, ist den DOMTree mit deinen Lineobjekten auf zu bauen. Falls du Probleme hast das Beispiel nach zu vollziehen lies die *Dokumentation*, da führt kein Weg dran vorbei.


```
Node no_x     = this.doc.createElement("x");
Text te_x    = this.doc.createTextNode(line.getX());
```


```
import java.awt.*;
public class Line implements Paintable 
{
	private int x, y, w, h;
	private Color color;
	public Line(Color color, int x, int y, int w, int h)
	{
		this.color = color;
		this.x = x;
		this.y = y;
		this.w = w;
		this.h = h;
	}
	public void paint( Graphics g )
	{
		g.setColor( color );
	    g.drawLine( x, y, w, h );
	} 
	public Color getColor()
	{
		return color;
	}
	public int getH()
	{
		return h;
	}
	public int getW()
	{
		return w;
	}
	public int getX()
	{
		return x;
	}
	public int getY()
	{
		return y;
	}
	public void setColor(Color color)
	{
		this.color = color;
	}
	public void setH(int i)
	{
		h = i;
	}
	public void setW(int i)
	{
		w = i;
	}
	public void setX(int i)
	{
		x = i;
	}
	public void setY(int i)
	{
		y = i;
	}
}
```


----------



## Pasche (5. Sep 2004)

ok, da werde ich mich mal schlau machen. aber eine frage habe ich da noch.
ich muss das ganze ja noch in mein programm einbauen. das speichern soll erstmal in meiner Klasse "ButtonPanel" bei einem Button hinterlegt werden. wie rufe ich das ganze dann auf ? Ich hätte gedacht, dass ich in der Klasse "PaintPanel", da wo mein Vektor existiert, eine Funktion save() anlege. Etwa so:


```
public void save(){
	  new XMLOutDemo();
   }
```

jetzt müsste ich ja in dieser funktion auch noch das save_document() aus der XMLDemo aufrufen. aber wie mache ich das von hier ?


----------



## foobar (5. Sep 2004)

Die Methode save_document() wird automatisch im Konstuktor von XmlOutDemo aufgerufen.


----------



## Pasche (5. Sep 2004)

Ich hab das ganze mal provisorisch in mein Programm integriert. Die Klasse XML Demo sieht dann wie folgt aus. Die Klasse Line habe ich von dir übernommen.


```
import java.io.File;
import java.io.FileOutputStream;
import java.util.Iterator;
import java.util.Vector;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;

import org.w3c.dom.Node;
import org.w3c.dom.Text;



public class XMLOutDemo
{
   private String filename;
   private Vector v_data;
   private Document doc;
   public XMLOutDemo()
   {
      this.v_data = PaintPanel.paints;
      this.filename  = "xmlout.xml";
      this.doc   = this.get_new_document();
      this.build_document();
      this.save_document();
      System.out.println("fertig");
   }
   
  private void build_document()
   {
      
      Node no_adrverw    = this.doc.createElement("adressenverwaltung");
      
      
      Iterator it = this.v_data.iterator();
      while (it.hasNext())
      {
         Line mit = (Line)it.next();
         Node no_adresse = this.doc.createElement("adresse");
                  
         Node no_nach    = this.doc.createElement("x");
         Text te_nach    = this.doc.createTextNode(String.valueOf(mit.getX()));
         Node no_url     = this.doc.createElement("Y");
         Text te_url    = this.doc.createTextNode(String.valueOf(mit.getY()));
         Node no_abt     = this.doc.createElement("H");
         Text te_abt    = this.doc.createTextNode(String.valueOf(mit.getH()));
         Node no_bon     = this.doc.createElement("W");
         Text te_bon    = this.doc.createTextNode(String.valueOf(mit.getW()));

         no_nach.appendChild(te_nach);
         no_url.appendChild(te_url);
         no_abt.appendChild(te_abt);
         no_bon.appendChild(te_bon);
                  
         no_adresse.appendChild(no_nach);
         no_adresse.appendChild(no_url);
         no_adresse.appendChild(no_abt);
         no_adresse.appendChild(no_bon);
      }
      
      this.doc.appendChild(no_adrverw);
   }
  
   
/*   private Vector get_dummy_data()
   {
      Vector vec = new Vector();
      vec.addElement(new Mitarbeiter("vorname 1","nachname 1"));
      vec.addElement(new Mitarbeiter("vorname 2","nachname 2"));
      vec.addElement(new Mitarbeiter("vorname 3","nachname 3"));
      return vec;
   }*/
   
   private Document get_new_document()
   {
      Document doc = null;
      try
      {
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
         DocumentBuilder builder  = factory.newDocumentBuilder();
         doc = builder.newDocument();
      }
      catch (Exception e) {e.printStackTrace();}
      return doc;
   }
   
   public void save_document()
   {   
      try
      {
         Transformer transformer = TransformerFactory.newInstance().newTransformer();
         DOMSource        source = new DOMSource( this.doc );
         FileOutputStream os     = new FileOutputStream( new File(this.filename) );
         StreamResult     result = new StreamResult( os );
         transformer.transform( source, result );
      }
      catch(Exception e){}
   }

  /* public static void main(String[] args)
   {
      new XMLOutDemo();   
   }*/
}
```

Das ganze funktioniert erstmal soweit, dass es fehlerfrei zu kompilieren ist :bae: 
Wenn ich dann mein Programm ausführe, ein paar Objekte der Klasse Line anlege und auf speichern klicke, wird eine XML-Datei erstellt. Allerdings steht darin nur "Adressverwaltun". Die Werte der einzelnen Line-Objekte werden noch nicht gespeichert.


----------



## foobar (5. Sep 2004)

Die einzelnen Lineelemente werden nicht an das Wurzelelement gehangen:

```
private void build_document()
   {
     
      Node no_adrverw    = this.doc.createElement("mygraphics");
      Iterator it = this.v_data.iterator();
      while (it.hasNext())
      {
         Line mit = (Line)it.next();
         Node no_adresse = this.doc.createElement("line");
                 
         Node no_nach    = this.doc.createElement("x");
         Text te_nach    = this.doc.createTextNode(String.valueOf(mit.getX()));
         Node no_url     = this.doc.createElement("Y");
         Text te_url    = this.doc.createTextNode(String.valueOf(mit.getY()));
         Node no_abt     = this.doc.createElement("H");
         Text te_abt    = this.doc.createTextNode(String.valueOf(mit.getH()));
         Node no_bon     = this.doc.createElement("W");
         Text te_bon    = this.doc.createTextNode(String.valueOf(mit.getW()));

         no_nach.appendChild(te_nach);
         no_url.appendChild(te_url);
         no_abt.appendChild(te_abt);
         no_bon.appendChild(te_bon);
                 
         no_adresse.appendChild(no_nach);
         no_adresse.appendChild(no_url);
         no_adresse.appendChild(no_abt);
         no_adresse.appendChild(no_bon);
         no_adrverw.append(no_adresse);
      }
     
      this.doc.appendChild(no_adrverw);
   }
```


----------



## Pasche (5. Sep 2004)

geschieht das über das


```
no_adrverw.append(no_adresse);
```

???

Das ist nämlich nicht bekannt ("Cannot resolve symbol")


----------



## foobar (5. Sep 2004)

Hab mich vertippt:

```
no_adrverw.appendChild(no_adresse);
```


----------



## Pasche (5. Sep 2004)

Ahhhhhh, es funktioniert  

Man, da bin ich dir ja einiges schuldig  8)  Naja, dann hab ich ja erstmal was zu tun um meine ganzen Klassen abzuändern. 

Um die Integer Daten zu speichern, hab ich ja diese Umwandlung gemacht:

```
Node no_nach    = this.doc.createElement("x");
         Text te_nach    = this.doc.createTextNode(String.valueOf(mit.getX()));
```

Gibt es auch eine Umwandlung für den Typ Color ? So dass ich die Farbe speichern kann ?


----------



## foobar (5. Sep 2004)

> Gibt es auch eine Umwandlung für den Typ Color ? So dass ich die Farbe speichern kann ?


Nein, da mußt du dir die RGB-Werte holen und einzeln abspeichern.


----------



## Pasche (5. Sep 2004)

OK, das bekomm ich wohl hin. 

Wo du gerade noch hier bist...  :wink: 

Ich hab ja jetzt verschiedene Klassen, z.B. Rect, Line oder Oval. Per if-Abfrage wollte ich jetzt das entsprechende Objekt speichern.


```
if (ButtonPanel.print == "rectangle")
		 {
  			Rect mit = (Rect)it.next();
            Node no_adresse = this.doc.createElement("rect");
		 }
      
  		 else if (ButtonPanel.print == "line")
		 {
			Line mit = (Line)it.next();
            Node no_adresse = this.doc.createElement("line");
		 } 
                 
         Node no_x    = this.doc.createElement("x");
         Text te_x    = this.doc.createTextNode(String.valueOf(mit.getX()));
         Node no_y     = this.doc.createElement("y");
         Text te_y    = this.doc.createTextNode(String.valueOf(mit.getY()));
         Node no_h     = this.doc.createElement("h");
         Text te_h    = this.doc.createTextNode(String.valueOf(mit.getH()));
         Node no_w     = this.doc.createElement("w");
         Text te_w    = this.doc.createTextNode(String.valueOf(mit.getW()));
```

Das kann ja so nicht funktionieren, da das Objekt dann nur innerhalb der if-Abfrage existiert. Aber ich möchte ja nicht jedesmal den ganzen Rest in der if-Abfrage haben. Wie mache ich das denn am besten ?


----------



## foobar (5. Sep 2004)

Um zu prüfen welche Runtimetype ein Objekt besitzt, benutzt man instanceof.

```
Object o = it.next();
if (o instanceof Line)
{
   Line myLine = (Line)o;
}
.....
```
Um auch nach dem If-Block auf die Variable zugriefen zu können, mußt du das Objekt im äusseren Block definieren.


```
Object o = it.next();
Line myLine = null;
if (o instanceof Line)
{
   myLine = (Line)o;javascript:
}
```


----------



## Pasche (5. Sep 2004)

das problem liegt eher in den folgenden zeilen:


```
Node no_x    = this.doc.createElement("x");
         Text te_x    = this.doc.createTextNode(String.valueOf(mit.getX()));
         Node no_y     = this.doc.createElement("y");
         Text te_y    = this.doc.createTextNode(String.valueOf(mit.getY()));
         Node no_h     = this.doc.createElement("h");
         Text te_h    = this.doc.createTextNode(String.valueOf(mit.getH()));
         Node no_w     = this.doc.createElement("w");
         Text te_w    = this.doc.createTextNode(String.valueOf(mit.getW()));
```

Hier muss ja das Objekt "mit" bekannt sein. Wenn ich jetzt ein Rechteck anlege, heißt das Objekt z.B. "rect", bei einer Linie ist es "line". Muss ich dann jedesmal diese ganzen Zeilen mit in die If-Abfrage packen ? Oder gibt es eine Möglichkeit, vorher ein unbestimmes Objekt anzulegen und das dann zu verwenden ?


----------



## foobar (6. Sep 2004)

> Oder gibt es eine Möglichkeit, vorher ein unbestimmes Objekt anzulegen und das dann zu verwenden ?


Jepp, mittels Polymorpie. Du erstellt dir ein Interface mit bestimmten Methoden, daß von allen deinen Klassen implementiert wird.
Am besten liest du erstmal mindestens ein gutes Buch zum Thema Java und OOP.
http://www.javabuch.de/
http://www.galileocomputing.de/openbook/javainsel/


----------



## Pasche (6. Sep 2004)

ich muss dieses blöde Malprogramm nur für ein Projekt machen, danach wollte ich mit Java nicht mehr so viel zu tun haben. Da wollte ich nicht unbedingt Stunden vor irgendwelchen Büchern sitzen. 

Ich weiß dass es sicherlich das Beste wäre, ich wär dir aber trotzdem dankbar, wenn du mir dafür noch ein Beispiel zeigen könntest.


----------



## foobar (6. Sep 2004)

```
interface SerializeGraphic
{
	public int getH();
	public int getW();
	public int getX();
	public int getY();
	public int getNodeName();
}
```


```
public class Line implements SerializeGraphic 
	{
		private int x, y, w, h;
		private Color color;
		public Line(Color color, int x, int y, int w, int h)
		{
			this.color = color;
			this.x = x;
			this.y = y;
			this.w = w;
			this.h = h;
		}
		public void paint(Graphics g)
		{
			g.setColor(color);
			g.drawLine(x, y, w, h);
		}
		public Color getColor()
		{
			return color;
		}
		public void setColor(Color color)
		{
			this.color = color;
		}
		public int getH()
		{
			return h;
		}
		public int getW()
		{
			return h;
		}
		public int getX()
		{
			return x;
		}
		public int getY()
		{
			return y;
		}
		public int getNodeName()
		{
			return "line";
		}
	}
```

......

```
SerializeGraphic gr = (SerializeGraphic) it.next();
Node no_adresse = this.doc.createElement( gr.getNodeName());
Node no_nach = this.doc.createElement(  gr.getX() );
```
.....


----------



## Guest (6. Sep 2004)

```
public int getNodeName()
      {
         return "line";
      }
```

Da bekomme ich die Fehlermeldung 

"incompatible types

found   : java.lang.String

required: int

      return "line";

             ^
"

Aber wenn ich eine Integer zurückgeben muss, bringt mir das doch nicht viel  ???:L


----------



## foobar (6. Sep 2004)

Das kommt davon, wenn man copy und paste macht ;-)

```
public String getNodeName()
{
      return "line";
}
```
Ich denke es sollte nun klar sein wie du vorgehen mußt.


----------



## Guest (6. Sep 2004)

Was jetzt aber noch fehlt, ist die Übergabe eines bestimmten Objektes. Im Moment ist ja nicht bekannt, von welchem Objekt denn die Daten übernommen werden sollen:


```
SerializeGraphic gr = (SerializeGraphic) it.next();
Node no_adresse = this.doc.createElement( gr.getNodeName());
Node no_nach = this.doc.createElement(  gr.getX() );
```

Wie kann ich denn jetzt festlegen, dass "gr" beispielsweise "Rect" ist etc.
Den Namen holt er sich ja mit "getNodeName", aber wie lege ich fest, von welchem Objekt ?


----------



## foobar (6. Sep 2004)

> Wie kann ich denn jetzt festlegen, dass "gr" beispielsweise "Rect" ist etc.
> Den Namen holt er sich ja mit "getNodeName", aber wie lege ich fest, von welchem Objekt ?


Alle deine Graphikobjekte müssen das Interface SerializeGraphic implementieren, dadurch sind sie alle kompatibel zu SerializeGraphic. Da du auf SerializeGraphic castest ist es egal ob du gerade ein Lineobjekt oder ein Rectobjekt verarbeitest, denn alle diese Objekte sind auch SerializeGraphicObjekte. 
Polylorphie ist ein ziemlich komplexes Thema, deshalb solltest du auf jeden Fall ein Javabuch lesen. Polymorphie und Vererbung wird dir in Java überall begegnen.


----------



## Guest (6. Sep 2004)

Es läuft jetzt alles wie ich es mir vorgestellt habe. Danke  :toll:

Wow, das war aber eine schwierige Geburt  :roll:


----------



## Thorsten (6. Sep 2004)

Das geht doch auch einfacher:


```
try 
{	
   FileOutputStream fos = new FileOutputStream("meinVector.xml");
   BufferedOutputStream bos = new BufferedOutputStream(fos);
			
   //XML Encoder erstellen
   XMLEncoder XML = new XMLEncoder(bos);
			
   //Den Vector schreiben
   XML.writeObject(meinVector);

   XML.close();
   XML = null;
}
catch (IOException e)
{
}
```

Dann habe ich eine XML-Datei mit dem Inhalt des Vectors   
Der XMLEncoder / XMLDecoder liegt in java.beans.


----------



## foobar (6. Sep 2004)

> Dann habe ich eine XML-Datei mit dem Inhalt des Vectors icon_smile.gif
> Der XMLEncoder / XMLDecoder liegt in java.beans.


Um einfach nur ein Objekt zu speichern ist XmlEncoder sicherlich die bessere Lösung. Aber wenn man die XmlDaten auch noch andersweitig verwenden will, ist eine Lösung mit DOM oder JDOM besser geeignet. Da man mit DOM mehr Kontrolle darüber hat wie die Daten gespeichert werden.


----------



## Slava (30. Nov 2005)

warum überfördern mit quelcode?
du brauchst kein XML. für deine zweke ist Serialisieren ausreichend

du muss deineclassen mit Serializable ergenzen etwa so


> class Line implements Paintable,Serializable{...


dann kannst du dein gefühlter Vector direkt in eine datei speichern so

```
try {
       FileOutputStream fs = new FileOutputStream("test.ser");
       ObjectOutputStream os = new ObjectOutputStream(fs);
       os.writeObject(deinvector);
       os.close();
     } catch (IOException e) {
       System.err.println(e.toString());
    }
```
um dein Vector aus datei auszulesen machst du so

```
try {
       FileInputStream fs = new FileInputStream("test.ser");
      ObjectInputStream is = new ObjectInputStream(fs);
       Vector deinvector = (Vector)is.readObject();
       System.out.println(time.toString());
       is.close();
     } catch (ClassNotFoundException e) {
       System.err.println(e.toString());
     } catch (IOException e) {
       System.err.println(e.toString());
     }
```
im vector gespeicherte Objecte sind so wie ich verstanden habe von Paintable abgeleitet
in einer schleife kannst du 
Paintable p= (Paintable)deinvector.next();
initialisieren .
wenn du mit xml mahen möchtest nim java.bean.XMLDecoder und java,bean.XMLEncoder damit kannst du direkt serialisieren aber das sieht wie eine xml aus!


----------



## Bleiglanz (30. Nov 2005)

warum nicht SVG?


----------



## Roar (30. Nov 2005)

warum einen thread nach über einem jahr wieder rauskramen? :?


----------

