Java基础知识——对象的序列化与反序列化

• 对象的序列化和反序列化
• 1)对象的序列化，就是把object转换为byte序列，反之叫对象的反序列化
• 2)序列化流(ObjectOutputStream),是过滤流------writeObject
•      反序列化流(ObjectInputSteam)-----------readObject
• 3)序列化接口(Serializable)
•      对象必须实现序列化接口，才能进行序列化，否则将出现异常
•      这个接口没有任何方法，只是一个标准
• 4)transient关键字(声明不用序列化的成员域)
• private void writeObject(java.io.ObjectOutputStream s)
•        throws java.io.IOException   //序列化操作方法
• private void readObject(java.io.ObjectInputStream s)
•        throws java.io.IOException, ClassNotFoundException   //反序列化操作方法
• 5)序列化中子类、父类构造函数的调用问题
• a.若一个类实现了序列化接口，那么其子类就可以进行序列化
•   b.对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用

• import java.io.*;
  /**
   * Student类
   */
  @SuppressWarnings("serial")
  public class Student implements Serializable{
  	private String stuno;
  	private String stuname;
  	private transient  int stuage;//该元素不会进行jvm默认的序列化，但可以自己完成这个元素的序列化
  	public Student() {
  	}
  
  	public Student(String stuno, String stuname, int stuage) {
  		super();
  		this.stuno = stuno;
  		this.stuname = stuname;
  		this.stuage = stuage;
  	}
  
  	public String getStuno() {
  		return stuno;
  	}
  
  	public void setStuno(String stuno) {
  		this.stuno = stuno;
  	}
  
  	public String getStuname() {
  		return stuname;
  	}
  
  	public void setStuname(String stuname) {
  		this.stuname = stuname;
  	}
  
  	public int getStuage() {
  		return stuage;
  	}
  
  	public void setStuage(int stuage) {
  		this.stuage = stuage;
  	}
  	@Override
  	public String toString() {
  		return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage=" + stuage + "]";
  	}
  	/**
  	 * 序列化操作方法
  	 */
  	 private void writeObject(java.io.ObjectOutputStream s)
  		        throws java.io.IOException{
  		 s.defaultWriteObject();//将jvm能默认进行序列化的元素进行序列化操作
  		 s.writeInt(stuage);//自己完成stuage的序列化
  		 
  	 }
  	 
  	 /**
  	  * 反序列化操作方法
  	  */
  	 private void readObject(java.io.ObjectInputStream s)
  		        throws java.io.IOException, ClassNotFoundException {
  		 s.defaultReadObject();//将jvm默认的反序列化的元素进行反序列化操作
  		 this.stuage = s.readInt();//自己完成stuage的反序列化操作
  	 }
  }
  

  import java.io.*;
  
  public class ObjectSeriaDemo {
  
  	
  	public static void main(String[] args) throws  Exception {
  		String file = "demo/obj.txt";
  		//对象序列化
  		ObjectOutputStream oos = new ObjectOutputStream(
  				new FileOutputStream(file));
  		Student stu = new Student("20147010","刘茜",20);
  		oos.writeObject(stu);
  		oos.flush();
  		oos.close();
  		
  		//对象的反序列化
  		ObjectInputStream ois = new ObjectInputStream(
  				new FileInputStream(file));
  		Student stu1 = (Student)ois.readObject();
  		System.out.println(stu1);
  		ois.close();
  	}
  
  }

   

  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  
  public class ObjectSeriaDemo1 {
  
  	public static void main(String[] args) throws Exception {
  		//序列化递归调用父类构造函数
  		ObjectOutputStream oos = new ObjectOutputStream(
  				new FileOutputStream("demo/obj2.txt"));
  		//Foo2 foo2 = new Foo2();
  		//oos.writeObject(foo2);
  		Bar2 bar2 = new Bar2();
  		oos.writeObject(bar2);
  		oos.flush();
  		oos.close();
  	
  	 //检测反序列是否也是递归调用父类构造函数
  	 //对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用
  	 ObjectInputStream ois = new ObjectInputStream(
  			 new FileInputStream("demo/obj2.txt"));
  	 //Foo2 foo2s =(Foo2)ois.readObject();
  	 //System.out.println(foo2s);
  	 Bar2 bar2s = (Bar2)ois.readObject();
  	 System.out.println(bar2s);
  	 ois.close();
  	 
  	}
  }
  /**
   * 一个类实现了序列化接口，那么其子类都可以进行序列化
   */
  @SuppressWarnings("serial")
  class Foo implements Serializable{
  	public Foo() {
  		System.out.println("Foo..........");
  	}
  }
  
  @SuppressWarnings("serial")
  class Foo1 extends Foo{
  	public Foo1() {
  		System.out.println("Foo1.........");
  	}
  }
  
  @SuppressWarnings("serial")
  class Foo2 extends Foo1{
  	public Foo2(){
  		System.out.println("Foo2.........");
  	}
  }
  class Bar {
  	public Bar(){
  		System.out.println("bar...");
  	}
  }
  class Bar1 extends Bar {
  	public Bar1(){
  		System.out.println("bar1...");
  	}
  }
  @SuppressWarnings("serial")
  class Bar2 extends Bar1 implements Serializable{
  	public Bar2(){
  		System.out.println("bar2...");
  	}
  }