from： http://zjx6820.iteye.com/blog/665992
在写原型模式的时候,在用clone()方法实现了的时候,发现对于深拷贝来说,会对每一个相关类添加clone方法.这样会增加代码量,故推荐在深拷贝的时候使用序列化与反序列化实行.参见于我写的原型模式. 
在写序列化的时候,我想到关于子类继承实现序列化的问题,倘若是父类实现了Serializable接口,那直接对子类序列化即可.倘若父类没有实现,而子类实现了Serializable,那仅能得到子类属性而得不到其集成自父类的属性了.当然倘若都不实现Serializable,那在序列化的时候是会报错的.对象序列化的时候必须实现Serializable. 
下面是父类实现了Serializable的代码: 
Java代码   收藏代码
  1. package serializable;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class SuperClass implements Serializable {  
  6.   
  7.      String name;  
  8.      String age;  
  9.   
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.     public void setName(String name) {  
  14.         this.name = name;  
  15.     }  
  16.     public String getAge() {  
  17.         return age;  
  18.     }  
  19.     public void setAge(String age) {  
  20.         this.age = age;  
  21.     }  
  22.       
  23.   
  24. }  

Java代码   收藏代码
  1. package serializable;  
  2.   
  3.   
  4. public class SonClass extends SuperClass {  
  5.     String sex;  
  6.     String profession;  
  7.   
  8.     public String getSex() {  
  9.         return sex;  
  10.   
  11.     }  
  12.   
  13.     public void setSex(String sex) {  
  14.         this.sex = sex;  
  15.     }  
  16.   
  17.     public String getProfession() {  
  18.         return profession;  
  19.     }  
  20.   
  21.     public void setProfession(String profession) {  
  22.         this.profession = profession;  
  23.     }  
  24.   
  25. }  

Java代码   收藏代码
  1. package serializable;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8.   
  9. public class Test {  
  10.     public static void main(String[] args) {  
  11.         SonClass son = new SonClass();  
  12.         son.setName("Alex");  
  13.         son.setAge("20");  
  14.         son.setProfession("fighter");  
  15.         son.setSex("man");  
  16.         SonClass son2=null;  
  17.         try {  
  18.             FileOutputStream ba = new FileOutputStream("text.txt");  
  19.             ObjectOutputStream oo = new ObjectOutputStream(ba);  
  20.             oo.writeObject(son);  
  21.             oo.flush();  
  22.             oo.close();  
  23.   
  24.             FileInputStream bi = new FileInputStream("text.txt");  
  25.             ObjectInputStream oi = new ObjectInputStream(bi);  
  26.             son2 = (SonClass) oi.readObject();  
  27.         } catch (IOException e) {  
  28.             // TODO Auto-generated catch block  
  29.             e.printStackTrace();  
  30.         } catch (ClassNotFoundException e) {  
  31.             // TODO Auto-generated catch block  
  32.             e.printStackTrace();  
  33.         }  
  34.   
  35.         System.out.println(son2.getName());  
  36.         System.out.println(son2.getAge());  
  37.         System.out.println(son2.getProfession());  
  38.         System.out.println(son2.getSex());  
  39.   
  40.     }  
  41. }  


当父类没有实现serializable,而子类实现的情况下,解决的办法是若父类有带参构造方法的时候,需要添加一个无参构造方法,子类中需要加上: 
Java代码   收藏代码
  1. private void writeObject(ObjectOutputStream out) throws IOException {  
  2.     out.defaultWriteObject();  
  3.     out.writeObject(name);  
  4.     out.writeObject(age);  
  5.   
  6. }  
  7.   
  8. private void readObject(ObjectInputStream in) throws IOException,  
  9.         ClassNotFoundException {  
  10.     in.defaultReadObject();  
  11.     name = (String) in.readObject();  
  12.     age = (String) in.readObject();  
  13. }  

此方法在序列化时候自动调用,先序列化子类,然后序列化父类的属性.