java序列化的作用
Java对象的序列化与反序列化-Json篇
Java对象的序列化与反序列化-Json篇说到Java对象的序列化与反序列化，我们⾸先想到的应该是Java的Serializable接⼝，这玩意在两个系统之间的DTO对象⾥⾯可能会⽤到，⽤于系统之间的数据传输。
或者在RPC（远程⽅法调⽤）时可能会⽤到。
但其实若是⽤于数据传输，xml和json两种数据格式⽤得更多⼀些。
但是为什么不⽤XStream呢，XStream确实好⽤，但是在Applet环境下可以使⽤的xml类库也就只有jdom了，连dom4j在Applet环境下都没有权限使⽤（Java反射的某些特性是需要权限的，Applet的安全机制不允许）。
扯远了，本⽂要说的是Java对象与Json的相互转换。
⽬前Java常⽤的Json类库有3种，即fastjson、jackson和gson，分别介绍如何将⼀个Java对象转换成Json和将⼀个Json字符串转换成Java对象，其实它们的⽤法⼤同⼩异。
⼀、⾸先看Maven依赖⼆、需要序列化的POJO和初始化代码三、fastjson的使⽤四、jackson的使⽤五、gson的使⽤⼀、⾸先看Maven依赖若不会maven，请参考Maven的基本⽤法：1 <!-- json -->2 <!-- 引⼊fastjson依赖 -->3 <dependency>4 <groupId>com.alibaba</groupId>5 <artifactId>fastjson</artifactId>6 <version>1.2.12</version>7 </dependency>8 <!-- 引jackson依赖 -->9 <!-- jackson核⼼包，必选，提供基于“流模式”解析的API -->10 <dependency>11 <groupId>com.fasterxml.jackson.core</groupId>12 <artifactId>jackson-core</artifactId>13 <version>2.7.4</version>14 </dependency>15 <!-- jackson注解包，可选，提供注解功能 -->16 <dependency>17 <groupId>com.fasterxml.jackson.core</groupId>18 <artifactId>jackson-annotations</artifactId>19 <version>2.7.4</version>20 </dependency>21 <!-- jackson数据绑定包，可选，提供基于“对象绑定”和“树模型”相关API -->22 <dependency>23 <groupId>com.fasterxml.jackson.core</groupId>24 <artifactId>jackson-databind</artifactId>25 <version>2.7.4</version>26 </dependency>27 <!-- 引⼊gson依赖 -->28 <dependency>29 <groupId>com.google.code.gson</groupId>30 <artifactId>gson</artifactId>31 <version>2.6.2</version>32 </dependency>⼆、需要序列化的POJO和初始化代码以下3种类库的使⽤均使⽤下⾯这个POJO1public class User {2public User(){}3private String id;4private String name;5private String password;6public String getId() {7return id;8 }9public void setId(String id) {10this.id = id;11 }12public String getName() {13return name;14 }15public void setName(String name) { = name;17 }18public String getPassword() {19return password;20 }21public void setPassword(String password) {22this.password = password;23 }24 @Override25public String toString() {26return"User [id=" + id + ", name=" + name + ", password=" + password27 + "]";28 }29 }1/**2 * 初始化User对象3 * @return user4*/5private static User initUser(){6 User user = new User();7 user.setId("1");8 user.setName("jison");9 user.setPassword("jison");10return user;11 }三、fastjson的使⽤fastjson的主要⼯具类是JSON，以下代码实现Java对象的序列化与反序列化1// 将Java对象序列化为Json字符串2 String objectToJson = JSON.toJSONString(initUser());3 System.out.println(objectToJson);4// 将Json字符串反序列化为Java对象5 User user = JSON.parseObject(objectToJson, User.class);6 System.out.println(user);四、jackson的使⽤jackson我们经常⽤到的是它的数据绑定包下的ObjectMapper类，以下代码实现Java对象的序列化与反序列化ObjectMapper objectMapper = new ObjectMapper();// 将Java对象序列化为Json字符串String objectToJson = objectMapper.writeValueAsString(initUser());System.out.println(objectToJson);// 将Json字符串反序列化为Java对象User user = objectMapper.readValue(objectToJson, User.class);System.out.println(user);五、gson的使⽤gson的主要⼯具类是Gson，使⽤GsonBuilder构造，以下代码实现Java对象的序列化与反序列化1 Gson gson = new GsonBuilder().create();2// 将Java对象序列化为Json字符串3 String objectToJson = gson.toJson(initUser());4 System.out.println(objectToJson);5// 将Json字符串反序列化为Java对象6 User user = gson.fromJson(objectToJson, User.class);7 System.out.println(user);以上3种json类库的完整代码如下：1public class JsonUtils {23/**4 * 初始化User对象5 * @return user6*/7private static User initUser(){8 User user = new User();9 user.setId("1");10 user.setName("jison");11 user.setPassword("jison");12return user;13 }1415public static void main(String[] args) throws Exception {16// fastjson⽤法17 fastjson();18// jackson⽤法19 jackson();20// gson⽤法21 gson();22 }2324private static void fastjson(){25// 将Java对象序列化为Json字符串26 String objectToJson = JSON.toJSONString(initUser());27 System.out.println(objectToJson);28// 将Json字符串反序列化为Java对象29 User user = JSON.parseObject(objectToJson, User.class);30 System.out.println(user);31 }3233private static void jackson() throws Exception{34 ObjectMapper objectMapper = new ObjectMapper();35// 将Java对象序列化为Json字符串36 String objectToJson = objectMapper.writeValueAsString(initUser());37 System.out.println(objectToJson);38// 将Json字符串反序列化为Java对象39 User user = objectMapper.readValue(objectToJson, User.class);40 System.out.println(user);41 }4243private static void gson(){44 Gson gson = new GsonBuilder().create();45// 将Java对象序列化为Json字符串46 String objectToJson = gson.toJson(initUser());47 System.out.println(objectToJson);48// 将Json字符串反序列化为Java对象49 User user = gson.fromJson(objectToJson, User.class);50 System.out.println(user);51 }52 }。
java序列化和serialVersionUID的使用方法实例
java序列化和serialVersionUID的使⽤⽅法实例java序列化和serialVersionUID的使⽤⽅法实例1、序列化：序列化可以将⼀个java对象以⼆进制流的⽅式在⽹络中传输并且可以被持久化到数据库、⽂件系统中，反序列化则是可以把之前持久化在数据库或⽂件系统中的⼆进制数据以流的⽅式读取出来重新构造成⼀个和之前相同内容的java对象。
2、序列化的作⽤：第⼀种：⽤于将java对象状态储存起来，通常放到⼀个⽂件中，使下次需要⽤到的时候再读取到它之前的状态信息。
第⼆种：可以让java对象在⽹络中传输。
3、序列化的实现：1)、需要序列化的类需要实现Serializable接⼝，该接⼝没有任何⽅法，只是标⽰该类对象可被序列化。
2）、序列化过程：使⽤⼀个输出流(如：FileOutputStream)来构造⼀个ObjectOutputStream(对象流)对象，接着，使⽤ObjectOutputStream对象的writeObject(Object obj)⽅法就可以将参数为obj的对象写出(即保存其状态)3)、反序列化过程：使⽤⼀个输⼊流(如：FileInputStream)来构造⼀个ObjectInputStream(对象流)对象，接着，使⽤ObjectInputStream对象的readObject(Object obj)⽅法就可以将参数为obj的对象读出(即获取其状态)4、静态long类型常量serialVersionUID的作⽤：如果没有设置这个值，你在序列化⼀个对象之后，改动了该类的字段或者⽅法名之类的，那如果你再反序列化想取出之前的那个对象时就可能会抛出异常，因为你改动了类中间的信息，serialVersionUID是根据类名、接⼝名、成员⽅法及属性等来⽣成⼀个64位的哈希字段,当修改后的类去反序列化的时候发现该类的serialVersionUID值和之前保存在问价中的serialVersionUID 值不⼀致，所以就会抛出异常。
数据序列化和反序列化
数据序列化和反序列化数据序列化和反序列化是计算机科学中非常重要的概念。
序列化是将一组数据转换为一个特定格式的字符串或字节，以便将其存储在文件或数据库中，或通过网络发送到其他计算机。
反序列化是将序列化后的数据还原为原始的数据结构或对象。
1. 序列化序列化是将数据结构或对象转换为可以持久化的字节序列或其他格式的过程。
在Java语言中，可以使用Java 序列化来完成这一过程。
在.NET框架中，可以使用XML、JSON、二进制格式和SOAP（Web服务）等进行序列化。
Java序列化的实现方式是将对象写入到一个二进制流中。
它需要实现java.io.Serializable接口，并且可以使用ObjectOutputStream进行序列化。
序列化后的数据可以存储到文件、数据库或通过网络发送到其他计算机。
.NET框架提供了多种序列化器。
其中XML序列化器可以将对象序列化为XML格式的字符串。
JSON序列化器可以将对象序列化为JSON格式的字符串。
二进制序列化器可以将对象序列化为二进制格式的字节数组。
SOAP序列化器可以将对象序列化为XML格式的SOAP消息。
序列化是一种重要的技术，可以用于数据的存储、传输以及远程方法调用等方面。
但是，在使用序列化时需要注意以下几点：（1）序列化的数据格式应该尽量小且简洁，以节省存储和传输带宽。
（2）序列化的数据应该具有跨平台和可移植性，以便于跨不同系统和语言进行数据交换。
（3）序列化的对象必须是可序列化的，即序列化的对象必须实现特定的接口或约定。
（4）由于序列化的过程可能带来性能损失，因此需要仔细考虑序列化的时间和代价。
2. 反序列化反序列化是将序列化后的数据还原为原始的数据结构或对象的过程。
在Java语言中，可以使用ObjectInputStream进行反序列化。
在.NET框架中，可以使用相应的反序列化器进行反序列化。
反序列化的过程是将二进制数据流转换为原始数据类型或对象的过程。
什么是Java序列化，如何实现java序列化
什么是Java序列化，如何实现java序列化简要解释： 序列化就是⼀种⽤来处理对象流的机制，所谓对象流也就是将对象的内容进⾏流化。
可以对流化后的对象进⾏读写操作，也可将流化后的对象传输于⽹络之间。
序列化是为了解决在对对象流进⾏读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接⼝，该接⼝没有需要实现的⽅法，implements Serializable只是为了标注该对象是可被序列化的，然后使⽤⼀个输出流(如：FileOutputStream)来构造⼀个ObjectOutputStream(对象流)对象，接着，使⽤ObjectOutputStream对象的writeObject(Object obj)⽅法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则⽤输⼊流。
详细解释：当两个进程在进⾏远程通信时，彼此可以发送各种类型的数据。
⽆论是何种类型的数据，都会以⼆进制序列的形式在⽹络上传送。
发送⽅需要把这个Java对象转换为字节序列，才能在⽹络上传送；接收⽅则需要把字节序列再恢复为Java对象。
只能将⽀持 java.io.Serializable 接⼝的对象写⼊流中。
每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引⽤的其他所有对象的闭包。
1.概念 序列化：把Java对象转换为字节序列的过程。
反序列化：把字节序列恢复为Java对象的过程。
2.⽤途 对象的序列化主要有两种⽤途： 1）把对象的字节序列永久地保存到硬盘上，通常存放在⼀个⽂件中； 2）在⽹络上传送对象的字节序列。
3.对象序列化序列化API java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)⽅法可对参数指定的obj对象进⾏序列化，把得到的字节序列写到⼀个⽬标输出流中。
序列化和反序列化的作用
序列化和反序列化的作用序列化和反序列化是计算机程序中重要的概念，用于将复杂的数据结构转化为二进制或文本格式的数据，以便在不同的程序或计算机之间传输或存储。
以下是序列化和反序列化的作用：1.数据传输在网络通信中，不同的程序之间需要传输数据以完成各种操作。
由于不同程序间可能使用不同的编程语言或数据格式，因此需要将数据转换为同一种格式进行传输。
序列化和反序列化能够将数据转化为通用的二进制或文本格式，使数据在不同程序和计算机之间能够传输和解析。
2.数据存储在程序设计中，经常需要将数据保存在文件、数据库或其他形式的存储介质中。
序列化和反序列化可以将数据转换为可持久保存的格式，使得数据在存储介质中可以长期保存，并且能够恢复到原来的数据结构，方便以后的使用。
3.远程过程调用在分布式系统中，应用程序可能会跨越多个计算机进行调用。
序列化和反序列化可以将调用的参数和返回值转换为网络标准格式，使得调用的过程可以跨越网络进行。
当传输出现问题时，数据可以恢复到原有的状态，保证了分布式系统的稳定性和可靠性。
4.数据压缩序列化和反序列化可以将数据压缩，减少传输和存储所需的空间和带宽。
当数据需要在网络上传输时，序列化和反序列化能够有效地压缩数据量，减少网络负载和传输时间。
5.安全性在数据传输或存储中，数据的安全性非常重要。
序列化和反序列化可以对数据进行加密或签名，保证数据的安全性。
通过序列化和反序列化，数据的接收者可以确定数据的来源和数据是否经过篡改，保证了数据的安全性和完整性。
总之，序列化和反序列化是计算机程序中不可或缺的技术，它使得程序能够处理复杂的数据结构，简化了程序的编写和维护。
同时，在分布式系统和网络通信中，序列化和反序列化也是实现稳定、可靠和安全传输的必要条件。
Java中实体类为什么要实现Serializable序列化的作用
Java中实体类为什么要实现Serializable序列化的作⽤客户端访问了某个能开启会话功能的资源， web服务器就会创建⼀个与该客户端对应的HttpSession对象，每个HttpSession对象都要站⽤⼀定的内存空间。
如果在某⼀时间段内访问站点的⽤户很多，web服务器内存中就会积累⼤量的HttpSession对象，消耗⼤量的服务器内存，即使⽤户已经离开或者关闭了浏览器，web服务器仍要保留与之对应的HttpSession对象，在他们超时之前，⼀直占⽤web服务器内存资源。
web服务器通常将那些暂时不活动但未超时的HttpSession对象转移到⽂件系统或数据库中保存，服务器要使⽤他们时再将他们从⽂件系统或数据库中装载⼊内存，这种技术称为Session的持久化。
将HttpSession对象保存到⽂件系统或数据库中，需要采⽤序列化的⽅式将HttpSession对象中的每个属性对象保存到⽂件系统或数据库中；将HttpSession对象从⽂件系统或数据库中装载如内存时，需要采⽤反序列化的⽅式，恢复HttpSession对象中的每个属性对象。
所以存储在HttpSession对象中的每个属性对象必须实现Serializable接⼝。
serialVersionUID 的作⽤serialVersionUID ⽤来表明类的不同版本间的兼容性Java的序列化机制是通过在运⾏时判断类的serialVersionUID来验证版本⼀致性的。
在进⾏反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进⾏⽐较，如果相同就认为是⼀致的，可以进⾏反序列化，否则就会出现序列化版本不⼀致的异常。
当实现java.io.Serializable接⼝的实体（类）没有显式地定义⼀个名为serialVersionUID，类型为long的变量时，Java序列化机制会根据编译的class⾃动⽣成⼀个serialVersionUID作序列化版本⽐较⽤，这种情况下，只有同⼀次编译⽣成的class才会⽣成相同的serialVersionUID 。
serialize()序列化方法
serialize()序列化方法serialize()是一种常用的序列化方法，它能够将对象转化为可以存储或传输的格式，从而实现对象的持久化或跨网络的传输。
在本文中，我们将深入探讨serialize()方法的原理、用法和一些注意事项。
一、序列化的概念和作用序列化是指将对象转化为字节流的过程，这样可以方便地进行存储、传输或通过网络进行远程调用。
序列化后的数据可以被存储到文件中，也可以通过网络传输给其他设备或系统。
反序列化则是将字节流转化为对象的过程，实现了对象的恢复。
序列化的作用主要有以下几个方面：1. 对象持久化：通过将对象序列化为字节流，可以将对象存储到硬盘上，以实现对象的持久化，即使在程序退出后也能够将对象恢复到内存中使用。
2. 网络传输：通过序列化对象，可以将对象转化为字节流，从而方便地在网络上进行传输，实现分布式系统之间的通信。
3. 跨平台通信：不同编程语言之间可以通过序列化和反序列化来进行通信，实现跨平台的数据交换。
二、serialize()方法的使用在Java语言中，使用serialize()方法可以将一个对象序列化为字节流。
该方法存在于Serializable接口中，因此需要对要序列化的类进行实现Serializable接口。
下面是一个示例代码：import java.io.*;public class SerializationDemo implements Serializable {public static void main(String[] args) {// 创建一个对象Student student = new Student("Tom", 20, "Male");try {// 创建一个输出流FileOutputStream fileOut = new FileOutputStream("student.ser");// 创建一个对象输出流ObjectOutputStream out = new ObjectOutputStream(fileOut);// 序列化对象out.writeObject(student);// 关闭输出流out.close();fileOut.close();System.out.println("对象已序列化并存储在student.ser 文件中");} catch (IOException e) {e.printStackTrace();}}}在上述代码中，我们创建了一个Student类，并实现了Serializable接口。
Java序列化接口Serializable接口的作用总结
Java序列化接⼝Serializable接⼝的作⽤总结⼀.Java序列化接⼝Serializable的作⽤：⼀个对象有对应的⼀些属性,把这个对象保存在硬盘上的过程叫做”持久化”.对象的默认序列化机制写⼊的内容是：对象的类，类签名，以及⾮瞬态和⾮静态字段的值。
(因为静态static的东西在⽅法区.)序列化能把堆内存中的对象的⽣命周期延长,做持久化操作.当下次再需要这个对象的时候,我们不⽤new了,直接从硬盘中读取就可以了.(存储到硬盘是⼀个⽂件,不需要我们去解析,如果⽤记事本打开解析会出现乱码,解析要⽤特定的⽅式,不⽤我们管. 我们只需要读取). 把对象存储到硬盘上的⼀个⽂件中,这个⽂件的标准扩展名是(.object).什么样的数据会进⾏序列化到硬盘进⾏持久化？①在很多框架中就会有这种.object结尾的⽂件,因为很多对象都不创建,创建起来太⿇烦,直接读取,⽽且有些对象的值你不知道,框架封存在.object⽂件中,直接读取这个⽂件中的这个值就⾏了,不需要传这个值.在搞web开发的时候⼀些类就需要实现序列化接⼝,因为服务器就会对你的对象进⾏临时本地存储.它怕服务器崩了的以后,你的会话都被消失了.所以存储在了硬盘上,你重新启动服务器会恢复之前的会话,恢复对象,你之前运⾏的东西都在.②对某些特点的对象,⽐如数据库连接对象,存储特定数据的对象 ,这样对象你不想创建他们,想存储起来,让他们的⽣命周期延长,可以把他们放在硬盘当中.每次系统启动的时候都到.object中读取对象和⾥⾯的数据,这个时候就可以把他们序列化来完成.⼆.具体举例：Person.java1import java.io.Serializable;2/*3 * Serializable:⽤于给被序列化的类加⼊ID号。
4 * ⽤于判断类和对象是否是同⼀个版本。
5*/6public class Person implements Serializable/*标记接⼝*/ {7/**8 * transient:⾮静态数据不想被序列化可以使⽤这个关键字修饰。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
最近在阅读Core J2EE Patterns 的时候发现例子里用于在各个层次里进行传输的TO（Data Transfer Object）都实现了java.io.Serializable接口，看到这些偶突然感到茅塞顿开～困扰了很久的关于Serializable的疑问渐渐解开了，查找相关资料并总结如下：序列化是什么：序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。
序列化分为两大部分：序列化和反序列化。
序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。
反序列化就是打开字节流并重构对象。
对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。
恢复数据要求有恢复数据的对象实例序列化的什么特点：如果某个类能够被序列化，其子类也可以被序列化。
声明为static和transient类型的成员数据不能被序列化。
因为static代表类的状态， transient代表对象的临时数据。
什么时候使用序列化：一：对象序列化可以实现分布式对象。
主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。
二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。
可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。
利用对象序列化可以进行对象的"深复制"，即复制对象本身及引用的对象本身。
序列化一个对象可能得到整个对象序列。
======================可以看看接口java.io.serializable的中文解释：Serializablepublic interface Serializable类通过实现 java.io.Serializable 接口以启用其序列化功能。
未实现此接口的类将无法使其任何状态序列化或反序列化。
可序列化类的所有子类型本身都是可序列化的。
序列化接口没有方法或字段，仅用于标识可序列化的语义。
要允许不可序列化类的子类型序列化，可以假定该子类型负责保存和还原超类型的公用(public)、受保护的 (protected) 和（如果可访问）包 (package) 字段的状态。
仅在子类型扩展的类有一个可访问的无参数构造方法来初始化该类的状态时，才可以假定子类型有此责任。
如果不是这种情况，则声明一个类为可序列化类是错误的。
该错误将在运行时检测到。
在反序列化过程中，将使用该类的公用或受保护的无参数构造方法初始化不可序列化类的字段。
可序列化的子类必须能够访问无参数的构造方法。
可序列化子类的字段将从该流中还原。
当遍历一个图形时，可能会遇到不支持可序列化接口的对象。
在此情况下，将抛出NotSerializableException，并将标识不可序列化对象的类。
在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法：private void writeObject(java.io.ObjectOutputStream out)throws IOExceptionprivate void readObject(java.io.ObjectInputStream in)throws IOException, ClassNotFoundException;writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它。
通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。
该方法本身不需要涉及属于其超类或子类的状态。
状态是通过使用 writeObject 方法或使用DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。
readObject 方法负责从流中读取并还原类字段。
它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的非静态和非瞬态字段。
defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。
这用于处理类发展后需要添加新字段的情形。
该方法本身不需要涉及属于其超类或子类的状态。
状态是通过使用writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入ObjectOutputStream 来保存的。
将对象写入流时需要指定要使用的替代对象的可序列化类，应使用准确的签名来实现此特殊方法：ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;此 writeReplace 方法将由序列化调用，前提是如果此方法存在，而且它可以通过被序列化对象的类中定义的一个方法访问。
因此，该方法可以拥有私有 (private)、受保护的(protected) 和包私有 (package-private) 访问。
子类对此方法的访问遵循 java 访问规则。
在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法。
ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;此 readResolve 方法遵循与 writeReplace 相同的调用规则和访问规则。
序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。
如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。
可序列化类可以通过声明名为"serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM) 对象序列化规范”中所述。
不过，强烈建议所有可序列化类都显式声明 serialVersionUID 值，原因计算默认的serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。
因此，为保证serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的serialVersionUID 值。
还强烈建议使用 private 修改器显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于立即声明类 -- serialVersionUID 字段作为继承成员没有用处。
java.io.Serializable引发的问题——什么是序列化？在什么情况下将类序列化？序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。
可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。
序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
序列化:序列化是将对象转换为容易传输的格式的过程。
例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。
在另一端，反序列化将从该流重新构造对象。
是对象永久化的一种机制。
确切的说应该是对象的序列化，一般程序在运行时，产生对象，这些对象随着程序的停止运行而消失，但如果我们想把某些对象（因为是对象，所以有各自不同的特性）保存下来，在程序终止运行后，这些对象仍然存在，可以在程序再次运行时读取这些对象的值，或者在其他程序中利用这些保存下来的对象。
这种情况下就要用到对象的序列化。
只有序列化的对象才可以存储在存储设备上。
为了对象的序列化而需要继承的接口也只是一个象征性的接口而已，也就是说继承这个接口说明这个对象可以被序列化了，没有其他的目的。
之所以需要对象序列化，是因为有时候对象需要在网络上传输，传输的时候需要这种序列化处理，从服务器硬盘上把序列化的对象取出，然后通过网络传到客户端，再由客户端把序列化的对象读入内存，执行相应的处理。
对象序列化是java的一个特征，通过该特征可以将对象写作一组字节码，当在其他位置读到这些字节码时，可以依此创建一个新的对象，而且新对象的状态与原对象完全相同。
为了实现对象序列化，要求必须能够访问类的私有变量，从而保证对象状态能够正确的得以保存和恢复。
相应的，对象序列化API能够在对象重建时，将这些值还原给私有的数据成员。
这是对java语言访问权限的挑战。
通常用在服务器客户端的对象交换上面，另外就是在本机的存储。
对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。
譬如通过网络传输,或者把一个对象保存成一个文件的时候,要实现序列化接口。
*Quote:比较java.io.Externalizable和java.io.Serializable[URL]/developer/code/story/0,3800066897,39304080,00.htm[ /URL]即使你没有用过对象序列化（serialization），你可能也知道它。
但你是否知道Java 还支持另外一种形式的对象持久化，外部化（externalization）？下面是序列化和外部化在代码级的关联方式：public interface Serializable {}public interface Externalizable extends Serializable {void readExternal(ObjectInput in);void writeExternal(ObjectOutput out);}序列化和外部化的主要区别外部化和序列化是实现同一目标的两种不同方法。