How about having your data-classes implement some sort of interface
which dictates that they provide an InputStream which are the bytes
representing the content of your data?

   Then your FileSaver class would take an instance of this interface, call
the method to get the InputStream, and read the bytes, and write those bytes
to the desired file.

   - Oliver

Would it make more sense for your generic file saver to return an open
OutputStream to the caller ? The caller would then use that to write
application-specific data to the file.  That seems simpler to me, than
expecting the caller to "package up" its output code in a form that can be
directly invoked by the FileSaver.

That does have the disadvantage that the caller will be expected to close() the
file, but personally I don't see that as a big enough problem to justify much
extra complexity.

Still, if you do want to ensure that the file is closed by the FileSaver you
could do something like

Define an Interface:

   interface FileWriter
   {
       void write(OutputStream out)
       throws IOException;
   }

Make your FileSaver take a FileWriter as one parameter (to its constructor or
to some other method).  E.g.

   class FileSaver
   {
       ....

       void promptAndSave(
           String suggestedFileName,
           // ...etc...
           FileWriter writer)
       throws IOException
       {
           // ...prompt for filename...
           //  ...open file...
           try
           {
               writer.write(output);
           }
           finally
           {
               output.close();
           }
       }

       ....
   }

And then when you use a FileWriter you can pass a local instance of FileWriter
to promptAndSave().  That instance might be one of your existing objects
(probably the object representing the data which is to be written to the file,
but extended to implement FileWriter), or almost as likely it would be
appropriate to create a local class (possibly an anonymous one, though I don't
like 'em myself), to do the job.

As I say, that's all a bit complicated.  It is undoubtedly cleaner, and in a
different language I would follow that pattern without hesitation, but Java
makes it pretty messy, and since the gain is only that I don't have to remember
to close() the stream, I'm not sure the mess is worth it.

   -- chris