2006年11月9日

转自： http://www.j2medev.com/code/j2se/language/200602/1343.html

import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
import  java.io.Serializable;

public class  CardReader  {
   public static  void  main ( String []  args ) {
     Card3 card =  new  Card3 ( 12 , Card3.SPADES ) ;
     System.out.println ( "Card to write is: "  + card ) ;

     try  {
       FileOutputStream out =  new  FileOutputStream ( "card.out" ) ;
       ObjectOutputStream oos =  new  ObjectOutputStream ( out ) ;
       oos.writeObject ( card ) ;
       oos.flush () ;
     }  catch  ( Exception e ) {
       System.out.println ( "Problem serializing: "  + e ) ;
     }

     Card3 acard =  null ;

     try  {
       FileInputStream in =  new  FileInputStream ( "card.out" ) ;
       ObjectInputStream ois =  new  ObjectInputStream ( in ) ;
       acard =  ( Card3 ) ( ois.readObject ()) ;
     }  catch  ( Exception e ) {
       System.out.println ( "Problem serializing: "  + e ) ;
     }

     System.out.println ( "Card read is: "  + acard ) ;

   }
}

class  Card3  implements  Serializable  {
   private  int  suit = UNASSIGNED;

   private  int  number = UNASSIGNED;

   public final static  int  UNASSIGNED = - 1 ;

   public final static  int  DIAMONDS =  1 ;

   public final static  int  CLUBS =  2 ;

   public final static  int  HEARTS =  3 ;

   public final static  int  SPADES =  4 ;

   public final static  int  ACE =  1 ;

   public final static  int  KING =  13 ;

   public  Card3 ( int  number,  int  suit ) {
     if  ( isValidNumber ( number )) {
       this .number = number;
     }  else  {
       //Error
     }

     if  ( isValidSuit ( suit )) {
       this .suit = suit;
     }  else  {
       //Error
     }
   }

   public  int  getSuit () {
     return  suit;
   }

   public  int  getNumber () {
     return  number;
   }

   public static  boolean  isValidNumber ( int  number ) {
     if  ( number >= ACE && number <= KING ) {
       return true ;
     }  else  {
       return false ;
     }
   }

   public static  boolean  isValidSuit ( int  suit ) {
     if  ( suit >= DIAMONDS && suit <= SPADES ) {
       return true ;
     }  else  {
       return false ;
     }
   }

   public  boolean  equals ( Object obj ) {
     if  ( obj  instanceof  Card3 ) {
       Card3 card =  ( Card3 )  obj;
       if  ( card.getNumber ()  ==  this .number && card.getSuit ()  ==  this .suit ) {
         return true ;
       }  else  {
         return false ;
       }
     }  else  {
       return false ;
     }
   }

   public  int  hashCode () {
     return  number * suit;
   }

   public  String toString () {
     return  numberToString ( this .number )  +  " of "  + suitToString ( this .suit ) ;
   }

   public static  String numberToString ( int  number ) {
     String result =  "" ;
     switch  ( number ) {
     case  ACE:
       result =  "Ace" ;
       break ;
     case  2 :
       result =  "Two" ;
       break ;
     case  3 :
       result =  "Three" ;
       break ;
     case  4 :
       result =  "Four" ;
       break ;
     case  5 :
       result =  "Five" ;
       break ;
     case  6 :
       result =  "Six" ;
       break ;
     case  7 :
       result =  "Seven" ;
       break ;
     case  8 :
       result =  "Eight" ;
       break ;
     case  9 :
       result =  "Nine" ;
       break ;
     case  10 :
       result =  "Ten" ;
       break ;
     case  11 :
       result =  "Jack" ;
       break ;
     case  12 :
       result =  "Queen" ;
       break ;
     case  KING:
       result =  "King" ;
       break ;
     case  UNASSIGNED:
       result =  "Invalid Number" ;
       break ;
     }
     return  result;
   }

   public static  String suitToString ( int  suit ) {
     String result =  "" ;
     switch  ( suit ) {
     case  DIAMONDS:
       result =  "Diamonds" ;
       break ;
     case  CLUBS:
       result =  "Clubs" ;
       break ;
     case  HEARTS:
       result =  "Hearts" ;
       break ;
     case  SPADES:
       result =  "Spades" ;
       break ;
     case  UNASSIGNED:
       result =  "Invalid Suit" ;
       break ;
     }
     return  result;
   }
}

接口 java.io.Serializable

public interface Serializable

实现 java.io.Serializable 接口的类是可序列化的。没有实现此接口的类将不能使它们的任一状态被序列化或逆序列化。序列化类的所有子类本身都是可序列化的。这个序列化接口没有任何方法和域，仅用于标识序列化的语意。

允许非序列化类的子类型序列化，子类型可以假定负责保存和恢复父类型的公有的、保护的和(如果可访问)包的域的状态。只要该类(扩展)有一个无参构造子，可初始化它的状态，那么子类型就可承担上述职责。在这种情况下申明一个可序列化的类是一个错误。此错误将在运行时被检测。

在逆序列化期间，将使用非序列化类的公用的或保护的无参构造子对它的域进行初始化。可序列化子类必须能访问父类的无参构造子。它的所有域将从相应流中被恢复。

当遍历一个图象时，很可能遇到一个不支持序列化接口的对象。此时将抛出 NotSerializableException 异常，且标识该非序列化对象类。

在序列化处理过程中需要特定句柄的类，必须使用如下这些恰当的标记实现特定的方法：

 private void writeObject(java.io.ObjectOutputStream out)
     throws IOException
 private void readObject(java.io.ObjectInputStream in)
     throws IOException, ClassNotFoundException; 
 

writeObject 方法负责写特定类的对象的状态，以至相应的 readObject 方法能恢复它。 通过调用 out.defaultWriteObject 可激活保存对象域的缺省机制。此方法不必关心状态是属于它的父类还是子类。 使用 writeObject 方法或基本类型支持的 DataOutput 方法将每个域的状态保存到 ObjectOutputStream 中。

readObject 方法负责从此流中读取并恢复类的域。它可能调用 in.defaultReadObject 方法来调用该对象的非静态和非暂时的域的缺省恢复机制。 defaultReadObject 方法使用该流中的信息，用当前对象中的已命名域分配保存在流中该对象的相应域。当类已改进增加了新域时，这个接口也做相应处理。此方法不必关心状态是属于它的父类还是子类。 使用 writeObject 方法或基本类型支持的 DataOutput 方法将每个域的状态保存到 ObjectOutputStream 中。