Problem z sterylizacją obiektów

Witam, piszę prostą aplikację katalogująca płyty.
Mój problem polega na tym iż strumień ObjectOutputStream nie chce zapisać klasy zawierającej listę obiektów do pliku. Objekty listy jak i sama klasa zawierająca listę są sterylizowane.

klasa Disc:

 
package data;
import java.io.Serializable;

public class Disc implements Serializable
{
    private String name;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }
}

klasa Library

package data;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
import java.io.Serializable;

public class Library implements Serializable
{
    private  static List <Disc> list = new ArrayList <Disc>();

    public static void addDisc(Disc disc)
    {
        list.add(disc);
    }

    public static void showLibrary()
    {
        for(Iterator<Disc> iter = list.iterator();iter.hasNext();)
        {
            System.out.println( iter.next().getName()+"\n");
        }
    }
}

Klasa Library tworzona jest w metodzie main:

 
public class Program
{
    static ProgramInterface programInterface;
    static DataFile data;
    static Library library;
    public static void main(String[] args)
    {
        try
        {
            UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
        }
        catch(ClassNotFoundException Ex)
        {
        }
        catch(InstantiationException IEx)
        {
        }
        catch(IllegalAccessException IIEx)
        {
        }
        catch(UnsupportedLookAndFeelException s)
        {
        }

        library = new Library();
        programInterface = new ProgramInterface();
        data = new DataFile("data.dat",library);
        
        
    }
}

Za sterylizowanie obiektu odpowiada klasa DataFile

 

public class DataFile 
{
    public static File file;
    private static Library library;

    public DataFile(String path, Library lib)
    {
        library = lib;
      

        file = new File(path);
        if(file.exists())
        {
        }
        else
        {
            try
            {
                file.createNewFile();
            }
            catch(IOException exception)
            {
                
            }
        }
    }

    public static void saveLibrary()
    {
       try
       {
        ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream(file));
        stream.writeObject(library);
        stream.flush();
        stream.close();
       }
       catch(FileNotFoundException filenotfoundexception)
       {

       }
       catch(IOException ioexception2)
       {

       }

    }
}

Metoda saveLibrary jest wywoływana w zdarzeniu:

 
public class AddDiscDialogEvent implements ActionListener
{


    public void actionPerformed(ActionEvent event)
    {
        Disc disc = new Disc();

        AddDialog dialog;
        dialog = (AddDialog)AddDialog.getDialog();
        disc.setName(dialog.getDiscName());
        Library.addDisc(disc);
        DataFile.saveLibrary();
        Library.showLibrary();
        AddDialog.getDialog().dispose();
    }
}

Plik data.dat jest tworzony, ale nie zwiera nic ciekawego. Tzn. nie widać w nim zapisanych stringów.

No, jak sa wysterylizowane to sie nie dziw ze nie dziala.
Sterylizacja obiektow :D

Wysterylizowane obiekty mają obniżone morale więc mogą nie działać prawidłowo <lol>

Pola statyczne nie są "sterylizowane", więc Library.list nie wysterylizujesz i żadnego obiektu Disc na pewno też. Po co właściwie wszędzie to static? Nie mówiąc już o tym, że i tak tworzysz obiekt Library.

Przy sterylizacji to lekarz pomaga :]

A jeśli chodzi o serializację, to poszukaj wzorca projektowego singleton (podstawowy wzorzec, choć nie do końca pozbawiony wad).

iooi napisał(a)

Pola statyczne nie są "sterylizowane", więc Library.list nie wysterylizujesz i żadnego obiektu Disc na pewno też. Po co właściwie wszędzie to static? Nie mówiąc już o tym, że i tak tworzysz obiekt Library.

Jako ciekawostka: http://download.oracle.com/javase/6/docs/platform/serialization/spec/serial-arch.html#6250
Pola statyczne nie sa serializowane tylko i wylacznie jako default, ktory mozna napisac za pomoca serialPersistentFields.

Wysterylizowane nadal jednak moga nie dzialac.