对象序列化

package cm;

import java.io.Externalizable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Random;

public class test20180423ObjectSerialization {

	public static void main(String[] args) {
		// 对象序列化的目的：在一台windows中生成的一个对象。经过序列化成一个字节序列之后，能够一个linux平台上完全恢复这个对象，弥补了不同的系统之间的差异。
		// 持久化：一个对象的生命周期并不取决于程序是否执行，它存在于程序调用之间。
		// 对象序列化能够达到轻量的持久化。将对象序列化写入磁盘。在程序调用的时候在重磁盘恢复这个对象。
		// 对象序列化是面向字节的，所以必须使用inputstream或outputstream包装成objectoutputstream和objectinputstream。
		// 在另一台机器上执行反序列化，必须保证jvm能找到需要反序列化对象的.class文件

		// Worm w=new Worm(6,'a');
		// System.out.println("w="+w);
		// try {
		// //采用文件读写
		// ObjectOutputStream out=new ObjectOutputStream(new
		// FileOutputStream("D:\\Worm.out"));//将对象序列化到一个文件。
		// out.writeObject("Worm sotrage\n");
		// out.writeObject(w);
		//
		// ObjectInputStream in=new ObjectInputStream(new
		// FileInputStream("D:\\Worm.out"));//将一个对象重一个文件输出。
		// String s= (String) in.readObject();//获取文件中的第一个对象。
		// Worm w2=(Worm) in.readObject();//获取第二个对象。
		// System.out.println(s+"w2="+w2);
		//
		// //采用字节数组读写
		// ByteArrayOutputStream bout=new ByteArrayOutputStream();
		// ObjectOutputStream out2=new ObjectOutputStream(bout);
		// out2.writeObject("Worm sotrage\n");
		// out2.writeObject(w);
		//
		// ObjectInputStream in2=new ObjectInputStream(new
		// ByteArrayInputStream(bout.toByteArray()));
		// String s2=(String) in2.readObject();
		// Worm w3=(Worm) in2.readObject();
		// System.out.println(s2+"w2+"+w3);
		//
		// } catch (IOException | ClassNotFoundException e) {
		// e.printStackTrace();
		// }

		// Externalizable是一个更加灵活的序列化接口。允许你控制序列化流程。
		// try {
		// ObjectOutputStream out =new ObjectOutputStream(new
		// FileOutputStream("D:\\blip.out"));
		// blip bl=new blip(66666);//传入一个密码666666
		// out.writeObject(bl);//自动调用bl对象的writeExternal方法。
		//
		//
		// ObjectInputStream in=new ObjectInputStream(new
		// FileInputStream("D:\\blip.out"));
		// blip bl2=(blip) in.readObject();//自动调用readExternal方法并将passwd初始化放在了此方法里边。
		// System.out.println(bl2.password);
		// } catch (FileNotFoundException e) {
		// e.printStackTrace();
		// } catch (IOException e) {
		// e.printStackTrace();
		// } catch (ClassNotFoundException e) {
		// // TODO Auto-generated catch block
		// e.printStackTrace();
		// }
		
		
		//transient关键字。
		//是针对serializable对象的。默认serializable对象默认是全部序列化。使用次关键词可打到部分序列化。使用此关键字可以逐个的关闭字段可被序列化。
		try {
			ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("D:\\transient.out"));
			transienttest ts=new transienttest("bigseacoming", "123");
			out.writeObject(ts);
			
			Thread.sleep(3000);
			ObjectInputStream in=new ObjectInputStream(new FileInputStream("D:\\transient.out"));
			transienttest ts2=(transienttest) in.readObject();
			System.out.println(ts2.toString());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		

	}

}
 
private class Date implements Serializable {
	private int n;

	public Date() {
		this.n = n;
	}

	public Date(int nextInt) {
		// TODO Auto-generated constructor stub
	}

	public String toString() {
		return Integer.toString(n);
	}
}

class Worm implements Serializable {
	private static Random rand = new Random();
	private Date[] d = { new Date(rand.nextInt(10)), new Date(rand.nextInt(10)), new Date(rand.nextInt(10)) };
	private Worm next;
	private char c;

	public Worm() {
		System.out.println("Worm default construction");
	}

	public Worm(int i, char x) {
		c = x;
		if (--i > 0) {
			next = new Worm(i, (char) (c + 1));// --i首先自减在判断，这里传入的i是6，6大于0，生成一个worm对象next，又调用next的构造函数。这样递归调用，每个worm对象里的next指针指向下一个worm对象。最后一个next为null；
		}
	}

	public String toString() {
		String s = ":" + c + "(";
		for (int i = 0; i < d.length; i++) {// d数组的长度为3
			s += d[i];
		}
		s += ")";
		if (next != null) {
			s += next;// 判断next是否是最后一个worm对象的前一个。若不是则，把next指定的对象追加到s，此时会调用next（worm）的头String（）方法，执行递归调用，知道最后一个。
		}
		return s;
	}
}

class blip implements Externalizable {
	int password;

	public blip() {// 实习那externalizable接口的类的缺省构造函数必须是pulic的，不像serization接口一样，这个接口恢复对象或会调用次对象的缺省构造器。
		System.out.println("default constructor");
	}

	public blip(int password) {
		this.password = password;
		System.out.println("using constructor 2");
	}

	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
		// 这个方法会在序列化对象重组是自动调用。
		System.out.println("boject readExternal");
		password = in.readInt();

	}

	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		// TODO Auto-generated method stub
		// 这个方法会在序列化对象的时候自动调用。
		System.out.println("boject writeExternal");
		out.writeInt(password);
	}
}
class transienttest implements Serializable{
	private String username;
	private transient String password;//使用关键字transientest避免了序列化的时候将修饰的字段序列化。
	public transienttest(String usernmae,String password) {
		this.username=usernmae;
		this.password=password;
	}
	public String toString() {
		return "login info:\nusername:"+username+"\npassword:"+password;
	}
	
}