基本概念
在介绍序列化之前，首先要知道以下几个概念：
非持久化：对于存在 jvm（java 虚拟机）的对象，其内部的状态只能保持在内存中，一旦 jvm 停止工作，内部的状态也就消失了，所以它是非持久化的。
持久化：如果想要永久的保存对象（即持久化），通常的作法是将其保存到文件或数据库。
序列化：在 java 中想要实现对象的持久化，就需要将其序列化，通过序列化，可以很容易的将 jvm 中的活动对象转换成字节数组（流）进行存储。
反序列化：将文件或数据库中的字节数组（流）转换成 jvm的活动对象。
在 java 中，类可以通过实现 serializable、externalizable 接口来序列化。
serializable 类一旦实现了 serializable 接口，表示它可以被序列化。
具体的序列化/反序列化操作则需要通过对象流（objectoutputstream /objectinputstream ）实现。
下面来看具体的例子：
class person implements serializable {
private string name;
private int age;
public person(string name ,int age){
this.name = name;
this.age =age;
}
public string getname() {
return name;
} public int getage() {
return age;
}
@override
public string tostring() {
return "name is " + name + " , age is " + age;
}
}public class test {
private final static string tempfile = "e:" + file.separator + "test.txt";
public static void main(string[] args) {
person person = new person("test",100);
write(person); // 关键 -> 序列化之后重新对对象进行赋值
person = new person("hello",999);
read(person); // 输出结果：
// name is test , age is 100，序列化成功
// 反序列化成功，name is test , age is 100
} // 通过 objectoutputstream 进行对象的序列化操作
private static void write(person person) { try {
objectoutputstream oos =
new objectoutputstream(new fileoutputstream(tempfile));
oos.writeobject(person);
oos.close();
system.out.println(person+"，序列化成功");
} catch (exception e) {
e.printstacktrace();
}
} // 通过 objectinputstream 进行对象的反序列化操作
private static void read(person person) { try {
objectinputstream ois =
new objectinputstream(new fileinputstream(tempfile));
person = (person) ois.readobject();
ois.close();
system.out.println("反序列化成功.，"+person);
} catch (exception e) {
e.printstacktrace();
}
}
}
观察输出结果，我们在对象序列化之后重新对其赋值，而通过反序列化的结果依然与对象序列化之前的值一致，这也间接证明对象被永久的存储下来，实现了持久化。
序列化失败序列化失败，有两种情况：不想被序列化、无法被序列化。
在类中，被关键字 transient、static 修饰的成员变量，表示自己不想被序列化。它会导致局部序列化失败。
在类中，存在成员变量是 thead 类型，则该类无法被序列化，它的影响是整体的。
下面来看这几种情况：
1.transient但凡变量被其修饰时，表示该参数是瞬态的，不想被序列化（不是无法序列化）。
// 序列化过程、调用过程与上述例子一致，省略代码...
// 这里只对内部类 person 的 age 属性进行修改class person implements serializable {
// 用 transient 修该变量
private transient int age;
// 省略部分代码...}
// 调用后的输出结果：
// name is test , age is 100，序列化成功
// 反序列化成功.，name is test , age is 0
观察输出结果，发现序列化之前 age 的是 100，而通过反序列化读取的 age 为 0。
int 类型的参数初始值为 0，这也正说明了该参数没有被序列化。
2.static但凡被其修饰的变量代表全局变量，访问全局变量时可以不依靠类对象。而序列化的操作是为了保存对象。正是由于这一特性与序列化的矛盾，导致全局变量默认不被序列化（不是无法序列化）。
// 序列化过程、调用过程与上述例子一致，省略代码...
// 这里只对内部类 person 的 name 属性进行修改class person implements serializable {
// 用 static 修该变量
private static string name;
// 省略部分代码...}
// 输出结果：
// name is test , age is 100，序列化成功//反序列化成功.，name is hello , age is 100
观察输出结果，发现 name 的值为 hello，不是序列化之前的 test。
前后值不一样说明其没有被序列化。又因为 static 的特性是与类有关，该变量序列化操作之后被重新赋值了，导致其值不是 null，而是 hello。
3.thread如果对象的成员变量含有 thread 类型，是无法被序列化的。
// 序列化过程、调用过程与上述例子一致，省略代码...
// 这里只对内部类 person 的 name 属性进行修改class person implements serializable {
//新增成员变量
private thread mythread = new thread();
//省略部分代码...}
// 输出结果（抛出异常）：
// caused by: java.io.notserializableexception: java.lang.thread
自定义序列化上面介绍了序列化失败的情况，那如果某些情况非要实现序列化呢（比如一定要实现全局变量的序列化）。那么需要在类中自定义序列化/反序列化过程，来看下面这个例子：
// 序列化操作代码与上面一致...
// 这里只对内部类 person 的属性进行修改。class person implements serializable {
private static string name;
private transient int age;
// 自定义序列化操作
private void writeobject(objectoutputstream out) throws ioexception{
out.defaultwriteobject();
out.writeobject(name);
out.writeint(age);
} // 自定义反序列化操作
private void readobject(objectinputstream in) throws ioexception,classnotfoundexception{
in.defaultreadobject();
name = (string) in.readobject();
age = in.readint();
}
// 省略部分代码...}
// 输出结果：
// name is test , age is 100，序列化成功
// 反序列化成功，name is test , age is 100
externalizable类通过实现 externalizable接口，也表示它可以被序列化，但它有两个限制：
接口强制实现了writeexternal 和 readexternal 方法用于自定义序列化与反序列化过程。
要求该类中必须含有无参构造函数。
同时由于它的序列化过程是定义在公共方法中的，所以不安全。
来看下面的例子：
// 序列化操作代码与上面一致，这里只对内部类 person 的进行修改。
class person implements externalizable { private static string name; private transient int age; // 重点 ->必须有无参构造函数
public person(){
}
public person(string name ,int age){
this.name = name;
this.age =age;
}
public string getname() {
return name;
}
public int getage() {
return age;
}
@override
public string tostring() {
return "name is " + name + " , age is " + age;
}
// 实现接口的方法
@override
public void writeexternal(objectoutput out) throws ioexception {
out.writeobject(name);
out.writeint(age);
}
// 实现接口的方法
@override
public void readexternal(objectinput in) throws ioexception, classnotfoundexception {
name = (string) in.readobject();
age = in.readint();
}
}
// 输出结果：
// name is test , age is 100，序列化成功
// 反序列化成功，name is test , age is 100
serialversionuid1.概念serialversionuid，即序列化版本号。
它的作用是：在序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
对于生成 serialversionuid，共有两种方式：
一种是固定值：1l
一种是经过 jvm 计算，不同的 jvm 采取的计算算法可能不同。
对于采用 jvm 生成的方式，它具有以下特点：
若对象的代码保持不变时，多次生成的serialversionuid也是不变的。
当对方法进行修改时，serialversionuid**不变**。
当对对象的属性进行修改时，重新生成的serialversionuid**会发生变化**。
因此说明序列化是作用于对象属性上的。
2.实例下面通过实例来探究下 serialversionuid 的具体作用：
首先我们对对象进行序列化操作（这里取消了反序列化的操作）
// 序列化操作代码与上面例子一致...// 这里取消了反序列化的操作public static void main(string[] args) {
person person = new person("test",100);
write(person);
person = new person("java", 200); //read(person);}
然后新增一个对象的属性，再进行反序列化操作
// 省略部分代码，与上面的代码一致...class person implements serializable { private string name; private age; //新增成员变量
private int phone; //省略部分代码...
}
}public static void main(string[] args) {
person person = new person("test",100); //write(person);
person = new person("java", 200);
read(person);
}// 输出结果（抛出异常）：// java.io.invalidclassexception: person;
观察代码，在序列化对象并没有添加 serialversionuid 的情况，在对象序列化之后如果改变了对象的属性，反序列化就会抛出异常。如果对象添加了 serialversionuid 就不会出现这种情况，这里就不验证了。
以上就是13.java 基础 - 序列化的内容。