Serializable对象序列化实例

a3mao — Thu, 09 Nov 2006 04:22:00 GMT

转自： 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;
   }
}

a3mao 2006-11-09 12:22 发表评论

Serializable

a3mao — Thu, 09 Nov 2006 04:12:00 GMT

接口 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 中。

a3mao 2006-11-09 12:12 发表评论

语源科技BlogJava-喜欢喝咖啡，喜欢Java

Serializable对象序列化实例

Serializable

接口 java.io.Serializable