Serializable?

Programação Java
#1

…alguem pode me explicar Serializable? Oque é… pra que serve, e se possivel um exemplo de onde é necessário!

[]'s

#2

Serialização de objetos permite tornar objetos de classes em sequencias de bytes, e depois restaurar para o objetos original. Atravez de uma rede, a serialização permite compensar diferenças entre sistemas operacionais.

Ou seja, vc pode criar um objeto em uma máquina Windows, serializá-lo, enviá-lo pela rede para uma máquina Unix e lá, ele será corretamente reconstruído.

Para gravar um objeto no disco e depois recuperá-lo deixando os detalhes para o sistema vc só precisa serializar o objeto.

Esse recurso é usado também para RMI (Remote Method Invocation) e JavaBeans , leia sobre se lhe interesar.

Tornar uma classe serializável é bem simples: vc só precisa implementar a interface Serializable (ela é só uma flag e não tem nenhum método). Quando vc faz isso, muitas classes padrões são mudadas para se tornarem serializáveis.

Para serializar o objeto (inplementando a interface), vc precisa criar um objeto da classe OutputStream e empacotá-lo dentro de um ObjectOutputStream. Daí, vc só precisa chamar writeObject() e seu objeto será serializado e mandado para o OutputStream. Para o processo reverso, vc empacota um InputStream dentro de um ObjectInputStream e chama readObject()

Segue exemplo tirado do livro Thinking in Java

//: c11:Worm.java
// Demonstrates object serialization.
import java.io.*;

class Data implements Serializable {
  private int i;
  Data(int x) { i = x; }
  public String toString() {
    return Integer.toString(i);
  }
}

public class Worm implements Serializable {
  // Generate a random int value:
  private static int r() {
    return (int)(Math.random() * 10);
  }
  private Data[] d = {
    new Data(r()), new Data(r()), new Data(r())
  };
  private Worm next;
  private char c;
  // Value of i == number of segments
  Worm(int i, char x) {
    System.out.println(" Worm constructor: " + i);
    c = x;
    if(--i > 0)
      next = new Worm(i, (char)(x + 1));
  }
  Worm() {
    System.out.println("Default constructor");
  }
  public String toString() {
    String s = ":" + c + "(";
    for(int i = 0; i < d.length; i++)
      s += d[i].toString();
    s += ")";
    if(next != null)
      s += next.toString();
    return s;
  }
  // Throw exceptions to console:
  public static void main(String[] args) 
  throws ClassNotFoundException, IOException {
    Worm w = new Worm(6, 'a');
    System.out.println("w = " + w);
    ObjectOutputStream out =
      new ObjectOutputStream(
        new FileOutputStream("worm.out"));
    out.writeObject("Worm storage");
    out.writeObject(w);
    out.close(); // Also flushes output
    ObjectInputStream in =
      new ObjectInputStream(
        new FileInputStream("worm.out"));
    String s = (String)in.readObject();
    Worm w2 = (Worm)in.readObject();
    System.out.println(s + ", w2 = " + w2);
    ByteArrayOutputStream bout =
      new ByteArrayOutputStream();
    ObjectOutputStream out2 =
      new ObjectOutputStream(bout);
    out2.writeObject("Worm storage");
    out2.writeObject(w);
    out2.flush();
    ObjectInputStream in2 =
      new ObjectInputStream(
        new ByteArrayInputStream(
          bout.toByteArray()));
    s = (String)in2.readObject();
    Worm w3 = (Worm)in2.readObject();
    System.out.println(s + ", w3 = " + w3);
  }
} ///:~

Tirei as informações do libro Thinking in Java, 2nd Edition, Revision 11, capítulo 11, no tópico Object Serialization. Esse livro tem por aí na internet.

#3