序列化流和反序列化流

1. 概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该 对象的数据 、对象的类型 和 对象中存储的属性等信息

字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化(使用Object类型来接收)

2. ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储

2.1 构造方法

FileOutputStream fileOut = new FileOutputStream("employee.txt"); 
ObjectOutputStream out = new ObjectOutputStream(fileOut);

2.2 序列化操作

1. 一个对象要想序列化，必须满足两个条件:
① 该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException

② 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用 transient 关键字修饰

public class Employee implements java.io.Serializable {     
	public String name;     
	public String address;     
	public transient int age; 
	// transient瞬态修饰成员,不会被序列化     
	public void addressCheck() {        
		System.out.println("Address  check : " + name + " ‐‐ " + address);        
	} 
}

2. writeObject
public final void writeObject (Object obj) : 将指定的对象写出

public class SerializeDemo{     
	public static void main(String [] args)   {        
		Employee e = new Employee();           
		e.name = "zhangsan";           
		e.address = "beiqinglu";           
		e.age = 20;            
		try {             
		// 创建序列化流对象                  
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));          
		// 写出对象               
		out.writeObject(e);               
		// 释放资源               
		out.close();               
		fileOut.close();               
		System.out.println("Serialized data is saved"); 
		// 姓名，地址被序列化，年龄没有被序列化。              
		} catch(IOException i)   {             
			i.printStackTrace();         
			}     
	}   
}

3. ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象

3.1 构造方法

3.2 反序列化操作

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用 ObjectInputStream 读取对象的方法：

两个异常
① ClassNotFoundException 异常:
对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常

② InvalidClassException 异常
另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操 作也会失败(该类的序列版本号与从流中读取的类描述符的版本号不匹配 )，抛出一个 InvalidClassException 异常

public static void main(String [] args)   {         
	Employee e = null;         
	try {                     
		// 创建反序列化流              
		FileInputStream fileIn = new FileInputStream("employee.txt");              
		ObjectInputStream in = new ObjectInputStream(fileIn);              
		// 读取一个对象              
		e = (Employee) in.readObject();             
		// 释放资源              
		in.close();              
		fileIn.close();         
	}catch(IOException i) {             
	 	// 捕获其他异常              
	 	i.printStackTrace();              
	 	return;         
	 }catch(ClassNotFoundException c)  {          
	 	// 捕获类找不到异常                   
	 	System.out.println("Employee class not found");              		
	 		c.printStackTrace();              
	 		return;         
	 	}         
	 	// 无异常,直接打印输出        
	 	 System.out.println("Name: " + e.name); // zhangsan            
	 	 System.out.println("Address: " + e.address); // beiqinglu         
	 	 System.out.println("age: " + e.age); // 0     
} 

4. static和transient

4.1 static关键字

静态关键字，优先于非静态加载到内存中，优先于对象被加载到内存，它不属于对象，所以他不能被序列化

4.2 transient关键字

被transient修饰变量的也不能被序列化，但是他没有静态的含义