// 在内存中创建图象
 int width = 60, height = 20;
 BufferedImage image = new BufferedImage(width, height,
   BufferedImage.TYPE_INT_RGB);

 // 获取图形上下文
 Graphics g = image.getGraphics();

 //生成随机类
 Random random = new Random();

 // 设定背景色
 g.setColor(getRandColor(200, 250));
 g.fillRect(0, 0, width, height);

 //设定字体
 g.setFont(new Font("Times New Roman", Font.PLAIN, 18));

 //画边框
 //g.setColor(new Color());
 //g.drawRect(0,0,width-1,height-1);

 // 随机产生155条干扰线，使图象中的认证码不易被其它程序探测到
 g.setColor(getRandColor(160, 200));
 for (int i = 0; i < 155; i++) {
  int x = random.nextInt(width);
  int y = random.nextInt(height);
  int xl = random.nextInt(12);
  int yl = random.nextInt(12);
  g.drawLine(x, y, x + xl, y + yl);
 }

 // 取随机产生的认证码(4位数字)
 String sRand = "";
 for (int i = 0; i < 4; i++) {
  String rand = String.valueOf(random.nextInt(10));
  sRand += rand;
  // 将认证码显示到图象中
  g.setColor(new Color(20 + random.nextInt(110), 20 + random
  .nextInt(110), 20 + random.nextInt(110)));
  //调用函数出来的颜色相同，可能是因为种子太接近，所以只能直接生成
  g.drawString(rand, 13 * i + 6, 16);
 }

 // 将认证码存入SESSION
 session.setAttribute("rand", sRand);

 // 图象生效
 g.dispose();

 // 输出图象到页面
 ImageIO.write(image, "JPEG", response.getOutputStream());
%>

一般报java.lang.NullPointerException的原因有以下几种：
·字符串变量未初始化；
·接口类型的对象没有用具体的类初始化，比如：
List lt；会报错
List lt = new ArrayList()；则不会报错了
·当一个对象的值为空时，你没有判断为空的情况。
你可以试着把下面的代码前加一行代码：
if(rb!=null && rb!="")
改成：
if(rb==null);
if(rb!==null&&rb!="")

解决步骤：

1、打开Console面板，找到出错信息。

2、从打印出来的信息中找出一个文件及其出错行数。

3、在出错行处设置断点，重新执行程序。

4、打开Variables视图，从中查找出错行所用到的所有对象及其值，如果其中对象的值为空，则可以进一步分析问题。

5、如果该行的对象都不为空而是调用了一个函数，则到这个函数里设置断点（或step into F5 ），继续进行调试。这时需要用F6（执行一行），直到再次报错，从而定位到出错处。重复步骤4.

6、结束。

如果不会断点,教你个狠的,你把用到的变量都输出出来,就知道谁是NULL了,然后在想办法改正,就简单多了

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/aisitemasu/archive/2008/05/29/2493246.aspx

　　第一：在web.xml文件<web-app> <servlet>"把下面的内容放在这里"</servlet></web-app>中加入

    <init-param>
    <param-name>application</param-name>
    <param-value>ApplicationResources</param-value>
    </init-param>

　　第二：在struts-config.xml中加入如下设置：

　　 <message-resources parameter="ApplicationResources"/>

　   该设置最好放在：</action-mappings>"放到这里"</struts-config>

　　第三：确保ApplicationResources.properties文件在你建立的WEB-INF\classes文件夹中。

　　可以把applicationResources.properties放到classes文件夹下其它目录，例如：
　　把ApplicationResources.properties放入WEB-INF\classes\mydir文件夹下。struts-config.xml中的设置必须改

     <message-resources parameter="mydir/ApplicationResources"/>
　　
    第四：就可能是键值的问题，struts的资源文件也是可以分多资源文件配置的，比如配备是这样的

    <message-resources parameter="ApplicationResources" key="myAppRes"/>      

   如果只有一个带key的资源文件，那就会抛出 org.apache.struts.action.MESSAGE错误了,删除key即可。

Java code

String encoding = "gb2312";
char c[] = {'u4f60'};
CharToByteConverter converter = CharToByteConverter.getConverter(encoding);
byte b[] = converter.convertAll(c);
for (int i = 0; i < b.length; i++) {
System.out.println(Integer.toHexString(b[i]));
}

Java code

String encoding = "gb2312";
char c[] = {'u4f60'};
CharToByteConverter converter = CharToByteConverter.getDefault();
byte b[] = converter.convertAll(c);
for (int i = 0; i < b.length; i++) {
System.out.println(Integer.toHexString(b[i]));
}

Java code

String encoding = "gb2312";
InputStreamReader reader = new InputStreamReader(new FileInputStream(
"text.txt"), encoding);
char c[] = new char[10];
int length = reader.read(c);
for (int i = 0; i < length; i++) {
System.out.println(c[i]);
}

XML code

<web-app>
<filter>
<filter-name>RequestFilter</filter-name>
<filter-class>net.golden.uirs.util.RequestFilter</filter-class>
<init-param>
<param-name>charset</param-name>
<param-value>gb2312</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>RequestFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
</web-app>

Java code

public void doFilter(ServletRequest req, ServletResponse res,
FilterChain fChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
HttpSession session = request.getSession();
String userId = (String) session.getAttribute("userid");
req.setCharacterEncoding(this.filterConfig.getInitParameter("charset")); // 设置字符集？实际上是设置了byte ??〉char的encoding
    try {
if (userId == null || userId.equals("")) {
if (!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}x2Ejsp$")) {
session.invalidate();
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logon.jsp");
}
}
else { // 看看是否具有信息上报系统的权限
        if (!net.golden.uirs.util.UirsChecker.check(userId, "信息上报系统",
net.golden.uirs.util.UirsChecker.ACTION_DO)) {
if (!request.getRequestURL().toString().matches(
".*/uirs/logon/logon(Controller){0,1}x2Ejsp$")) {
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logonController.jsp");
}
}
}
}
catch (Exception ex) {
response.sendRedirect(request.getContextPath() +
"/uirs/logon/logon.jsp");
}
fChain.doFilter(req, res);
}

目前网络上关于对象序列化的文章不少，但是我发现详细叙述用法和原理的文章太少。本人把自己经过经验总结和实际运用中的体会写成的学习笔记贡献给大家。希望能为整个java社区的繁荣做一点事情。

      序列化的过程就是对象写入字节流和从字节流中读取对象。将对象状态转换成字节流之后，可以用java.io包中的各种字节流类将其保存到文件中，管道到另 一线程中或通过网络连接将对象数据发送到另一主机。对象序列化功能非常简单、强大，在RMI、Socket、JMS、EJB都有应用。对象序列化问题在网 络编程中并不是最激动人心的课题，但却相当重要，具有许多实用意义。

一：对象序列化可以实现分布式对象。
      主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。

二： java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传 递。利用对象序列化可以进行对象的“深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。

   从上面的叙述中，我们知道了对象序列化是java编程中的必备武器，那么让我们从基础开始，好好学习一下它的机制和用法。

     java 序列化比较简单，通常不需要编写保存和恢复对象状态的定制代码。实现java.io.Serializable接口的类对象可以转换成字节流或从字节流恢 复，不需要在类中增加任何代码。只有极少数情况下才需要定制代码保存或恢复对象状态。这里要注意：不是每个类都可序列化，有些类是不能序列化的，例如涉及 线程的类与特定JVM有非常复杂的关系。
序列化机制：

     序列化分为两大部分：序列化和反序列化。 序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型 转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例。ObjectOutputStream中的序列化过程与字节流连接，包括对象类型 和版本信息。反序列化时，JVM用头信息生成对象实例，然后将对象字节流中的数据复制到对象数据成员中。下面我们分两大部分来阐述：

处理对象流：
（序列化过程和反序列化过程）

   java.io包有两个序列化对象的类。ObjectOutputStream负责将对象写入字节流，ObjectInputStream从字节流重构对象。
     我们先了解ObjectOutputStream类吧。ObjectOutputStream类扩展DataOutput接口。
writeObject ()方法是最重要的方法，用于对象序列化。如果对象包含其他对象的引用，则writeObject()方法递归序列化这些对象。每个 ObjectOutputStream维护序列化的对象引用表，防止发送同一对象的多个拷贝。（这点很重要）由于writeObject()可以序列化整 组交叉引用的对象，因此同一ObjectOutputStream实例可能不小心被请求序列化同一对象。这时，进行反引用序列化，而不是再次写入对象字节 流。

下面，让我们从例子中来了解ObjectOutputStream这个类吧。
1. // 序列化 today's date 到一个文件中.
2.      FileOutputStream f = new FileOutputStream("tmp");
3.      ObjectOutputStream s = new ObjectOutputStream(f);
4.      s.writeObject("Today");
5.      s.writeObject(new Date());
6.      s.flush();

    现在，让我们来了解ObjectInputStream这个类。它与 ObjectOutputStream相似。它扩展DataInput接口。ObjectInputStream中的方法镜像 DataInputStream中读取Java基本数据类型的公开方法。readObject()方法从字节流中反序列化对象。每次调用 readObject()方法都返回流中下一个Object。对象字节流并不传输类的字节码，而是包括类名及其签名。readObject()收到对象 时，JVM装入头中指定的类。如果找不到这个类，则readObject()抛出ClassNotFoundException,如果需要传输对象数据和 字节码，则可以用RMI框架。ObjectInputStream的其余方法用于定制反序列化过程。

例子如下：
1. //从文件中反序列化 string 对象和 date 对象
2.      FileInputStream in = new FileInputStream("tmp");
3.      ObjectInputStream s = new ObjectInputStream(in);
4.      String today = (String)s.readObject();
5.      Date date = (Date)s.readObject();

定制序列化过程:

       序列化通常可以自动完成，但有时可能要对这个过程进行控制。java可以将类声明为serializable，但仍可手工控制声明为static或transient的数据成员。
例子：一个非常简单的序列化类。
1. public class simpleSerializableClass implements Serializable{
2.      String sToday="Today:";
3.      transient Date dtToday=new Date();
4. }

       序列化时，类的所有数据成员应可序列化除了声明为transient或static的成员。将变量声明为 transient告诉JVM我们会负责将变元序列化。将数据成员声明为transient后，序列化过程就无法将其加进对象字节流中，没有从 transient数据成员发送的数据。后面数据反序列化时，要重建数据成员（因为它是类定义的一部分），但不包含任何数据，因为这个数据成员不向流中写 入任何数据。记住，对象流不序列化static或transient。我们的类要用writeObject()与readObject()方法以处理这些 数据成员。使用writeObject()与readObject()方法时，还要注意按写入的顺序读取这些数据成员。

关于如何使用定制序列化的部分代码如下：

1. //重写writeObject()方法以便处理transient的成员。
2. public void writeObject(ObjectOutputStream outputStream) throws IOException{
3.      outputStream.defaultWriteObject();//使定制的writeObject()方法可以
4.                          利用自动序列化中内置的逻辑。
5.      outputStream.writeObject(oSocket.getInetAddress());
6.      outputStream.writeInt(oSocket.getPort());
7. }
8. //重写readObject()方法以便接收transient的成员。
9. private void readObject(ObjectInputStream inputStream) throws IOException,ClassNotFoundException{
10.      inputStream.defaultReadObject();//defaultReadObject()补充自动序列化
11.      InetAddress oAddress=(InetAddress)inputStream.readObject();
12.      int iPort =inputStream.readInt();
13.      oSocket = new Socket(oAddress,iPort);
14.      iID=getID();
15.      dtToday =new Date();
16. }

完全定制序列化过程:

       如果一个类要完全负责自己的序列化，则实现 Externalizable接口而不是Serializable接口。Externalizable接口定义包括两个方法writeExternal ()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流.类实现Externalizable时，头写入对象流中，然后类 完全负责序列化和恢复数据成员，除了头以外，根本没有自动序列化。这里要注意了。声明类实现Externalizable接口会有重大的安全风险。 writeExternal()与readExternal()方法声明为public，恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信 息，则要格外小心。这包括使用安全套接或加密整个字节流。到此为至，我们学习了序列化的基础部分知识.

}
用 serialPersistentFields 为某个类定义可序列化域后，即无需再将可序列化域限制在当前 Serializable 类的定义之内。利用第 1.7 节，"访问类的可序列化域" 中描述的接口，Serializable 类的 writeObject 和 readObject 方法可将该类的当前实现映射到其可序列化域。因此，后续版本中可以改变 Serializable 类的域，但前提是保持与版本兼容的 Serializable 域的映射。

1.6 对类的可序列化域和数据存档
对类的可序列化状态进行存档以使其与 Serializable 类的其它实现间可互操作，或者对类演变进行存档，这些都非常必要。对可序列化域进行存档可帮助用户最终确定该域是否应序列化。 序列化 javadoc 标记 @serial、@serialField 和 @serialData 可提供对源代码中 Serializable 类的序列化形式进行存档的方法。

对于缺省的可序列化域，@serial 标记应放在 javadoc 注释中。语法如下：@serial field-description 其中可选项 field-description 描述域及其容许值的含义。 field-description 可跨多行。当初始版本中增加一个域时，@since 标记指出所添域的版本。@serial 的 field-description 提供针对序列化的文档。在序列化形式文档内，field-description 将被添加到 javadoc 注释中。
@serialField 标记用于对 serialPersistentFields 数组的 ObjectStreamField 组件进行存档。每个 ObjectStreamField 组件都应使用其中的一个标记。语法如下：@serialField field-name field-type field-description
@serialData 标记描述写入或读取数据的次序和类型。该标记描述 writeObject 所写入的可选数据或 Externalizable.writeExternal 方法所写入的所有数据的次序或类型。语法如下：@serialData data-description
javadoc 应用程序识别序列化 javadoc 标记并为每个 Serializable 和 Externalizable 类生成说明文字。有关这些标记用法的示例，参见第 C.1 节 "java.io.File 可替代实现的示例。"

当某个类被声明为 Serializable 时，即通过可序列化域及可选数据（按名称和类型）定义了该对象的可序列化状态。可选数据只能用 Serializable 类中的 writeObject 方法显式写入，而其读取则可通过 Serializable 类和 readObject 方法进行。否则，序列化将跳过无法读取的可选数据。

当一个类被声明为 Externalizable 时，通过类自身写入流的数据即定义了该类的序列化状态。 该类必须指定顺序、类型及写入流的每个数据的含义。同时还必须处理其自身的演变，从而可读取以前版本所写入的数据，或写入以前版本所能读取的数据。在存储和恢复数据时，该类必须与父类相一致。必须指定流中父类数据的位置。

类的设计者必须确保为类存储的信息对于持久性是合适的，而且遵循为实现序列化的互操作性和演变而指定的序列化规则。第 5 章“可序列化对象的版本演变”对类的演变进行了更详细的说明。

1.10 Serializable 接口
Serialization 对象生成流，其中提供有关所存对象的 JavaTM 类的信息。对于可序列化对象，即使存在该类的不同（但兼容）版本的实现，也要保持足够的信息以恢复这些对象。定义 Serializable 接口可以标识实现可序列化协议的类：

package java.io;

public interface Serializable {};

Serializable 类必须具备如下功能：

实现 java.io.Serializable 接口
标识应序列化的域
(使用 serialPersistentFields 成员以显式声明其可序列化，或者使用瞬态关键字来指示非序列域。)
可访问其第一个非序列化父类的无参数构造函数。
该类可根据需要定义如下方法：

writeObject 方法，用于控制要保存哪些信息或将附加信息添加到流中
readObject 方法，用于读取由相应 writeObject 方法写入的信息，或在对象恢复后更新其状态
writeReplace 方法，用于允许类指定写入流的替换对象
readResolve 方法，用于允许类为刚从流中读取的对象指定替换对象
ObjectOutputStream 和 ObjectInputStream 支持所操作的可序列化类的演变（允许类发生改变以兼容早期版本的类）。有关实现兼容变化的机制的信息，参见第 5.5 节“兼容的 JavaTM 类型演变”。
--------------------------------------------------------------------------
class ObjectYouWannaSave implements Serializable{
   int x; int y;
   SubObject so = new SubObject();
   ..........
}

class SubObject implements Serializable{
   String s = "abc"; //String is OK, because String is java.io.Serializable
}

public class Save{ // in Save.java
   public void main(String[] args) {
      ObjectYouWannaSave original = new ObjectYouWannaSave();
      original.x = -1; original.y = 100; .....
     
      ObjectOutputStream out = null;
      try{
        out = new ObjectOutputStream(new FileOutputStream(new File("c:/save.dat")));
        out.writeObject(original);
      }catch(Exceptione){
      }finally{
        try{out.close();}catch(Exception e){}
      }
   }
}

public class Read{ // in Read.java
   public void main(String[] args) {
      ObjectInputStream in = null;
      try{
        out = new ObjectInStream(new FileInStream(new File("c:/save.dat")));
        ObjectYouWannaSave o = (ObjectYouWannaSave)in.readObject();
        System.out.println("x="+o.x);
        System.out.println("subobject.string=" + o.so.s);
        ........
      }catch(Exceptione){
      }finally{
        try{in.close();}catch(Exception e){}
      }
   }
}

这是个最简单的例子，先运行Save,以后什么时候运行Read都可以（只要c:\save.dat文件还存在就可以了）
--------------------------------------------------
对象的寿命通常随着生成该对象的程序终止而终止，有时候，可能需要将对象的状态保存下来，在需要的时候
再将对象恢复，我们把对象的这种记录自己状态的以便将来再生的能力，叫做对象的持续性（PERSISTENCE），
对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化Serializable。串行化的主要任务是写
出对象实例变量的值。如果变量是另一个对象的引用，则引用的对象也要串行化，这是个递归过程。
--------------------------------------------------------------------
java.io.Serializable interface是一个较为特殊的接口：
The serialization interface has no methods or fields and serves
only to identify the semantics of being serializable
即：它主要是一个用于通知JVM的标志

class X implements java.io.Serializable{...}

如果你要定制你自己的serializable行为，你应该在X中实现以下2个方法：
 private void writeObject(java.io.ObjectOutputStream out)
     throws IOException
 private void readObject(java.io.ObjectInputStream in)
     throws IOException, ClassNotFoundException;

否则将按缺省的策略进行。

由于上述2个方法是private的，所以在某些情况下，可以使用
java.io.Serializable的子接口java.io.Externalizable，
在这个interface中有2个public方法：

public void writeExternal(ObjectOutput out)
                   throws IOException

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

----------------------------------------------------------------------------
Serializable是一个串行化接口，它没有任何的属性和方法，一个类实现了串行化接口，就表明
该类具有持久性，通过WriteObjcet可将其持久保存在磁盘，在需要时，可用ReadObject从磁盘中读出，次时，对象的状态和存入似的相同。上面给出的列子比较简单，可通过串行化保存一个
链表对象，它的每个节点数据也会被保存。 当然，串行化接口还有其他用途，例如HTTP隧道等
。
-----------------------------------------------------------------------
对象序列化的持续性要和永久对象分别开。序列化只能达到有线持续性
在同一个jvm上可以重构对象的内容，达到持续性
---------------------------------------------------------------------
java序列化主要是用于两个方面：
一个是java的RMI（远程方法调用－Remote method invocation），你可以使用别人机器上的对象就像在你自己的机器上使用它一样（通过序列化），另外，在使用javabean时也需要使用序列化，序列化主要就是使用在这两方面。
-------------------------------------------------------------
所谓序列化就是把把对象以一个代码串的形式表示出来，
这样可以保存到磁盘或则通过网络传输，接受方可以在把代码串恢复成对象
具体的串形化方法可以自己写，接收放就可以根据您串形的规则把对象恢复出来
--------------------------------------------------------------------
序列化是把一个对象的状态写入一个字节流的过程，它执行RMI，RMI允许一台机器上的JAVA对象调用不同机器上的JAVA对象方法，对象可以作为参数提供给那个远程方法，发送机序列化该对象并传送它，接收机执行反序列化。
序列化和反序列化的关系图表可形成包含循环引用的顺序图表。这是整个序列化的总体思想。
而Serializable接口属于支持序列化的一个接口，只有一个实现它的对象可以被序列化工具存储和回复，Serializable接口没有定义任何成员，只用来表示一个累可以被序列化，若该类可以序列化，那么它的所有子类都可以。
下面是关于序列化的一个实例：
[b:a55efb5f91]程序名称：SerializationDemo.java
程序主题：实现对象的序列化和反序列化
程序说明：该程序由实例化一个MyClass类的对象开始，该对象有三个实例变量，类型分别为String、int、double，是希望存储和恢复的信息。[/b:a55efb5f91]

[code:1:a55efb5f91]

import java.io.*;

public class SerializationDemo{
        public static void main(String args[]){

//Object serialization
try{
MyClass object1=new MyClass("Hello",-7,2.7e10);
System.out.println("object1:"+object1);
FileOutputStream fos=new FileOutputStream("serial");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(object1);
oos.flush();
oos.close();
}
catch(Exception e){
System.out.println("Exception during serialization:"+e);
System.exit(0);
}

//Object deserialization
try{
MyClass object2;
FileInputStream fis=new FileInputStream("serial");
ObjectInputStream ois=new ObjectInputStream(fis);
object2=(MyClass)ois.readObject();
ois.close();
System.out.println("object2:"+object2);
}
catch(Exception e){
System.out.println("Exception during deserialization:"+e);
System.exit(0);
}
}
}

class MyClass implements Serializable{
String s;
int i;
double d;
public MyClass(String s,int i,double d){
this.s=s;
this.i=i;
this.d=d;
}
public String toString(){
return "s="+s+";i="+i+";d="+d;
}
}
[/code:1:a55efb5f91]

程序运行结果：object1和object2的实例变量是一样的，输出如下：[code:1:a55efb5f91]object1:s=Hello;i=-7;d=2.7E10
object2:s=Hello;i=-7;d=2.7E10[/code:1:a55efb5f91]
--------------------------------------------------------------------------------
Object serialization的定义：
Object serialization 允许你将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象。 

serialization不但可以在本机做，而且可以经由网络操作（就是猫小说的RMI）。这个好处是很大的----因为它自动屏蔽了操作系统的差异，字节顺序（用Unix下的c开发过网络编程的人应该知道这个概念，我就容易在这上面犯错）等。比如，在Window平台生成一个对象并序列化之，然后通过网络传到一台Unix机器上，然后可以在这台Unix机器上正确地重构这个对象。

Object serialization主要用来支持2种主要的特性：
1。Java的RMI(remote method invocation).RMI允许象在本机上一样操作远程机器上的对象。当发送消息给远程对象时，就需要用到serializaiton机制来发送参数和接收返回直。

2。Java的JavaBeans.   Bean的状态信息通常是在设计时配置的。Bean的状态信息必须被存起来，以便当程序运行时能恢复这些状态信息。这也需要serializaiton机制。

二。持久化
持久化应该是英文里的persistence.但是Java语言里现在只支持lightweight persistence,就是轻量级持久化，这是通过serialization机制来实现的。

persistence是指一个对象的生命周期不由程序是否执行来决定，即使是在程序终止时这个对象也存在。它把一个serializable的对象写到磁盘（本机或其他机器上的非RAM存储器），并在程序重新调用时再读取对象到通常的RAM存储器。

为什么说Java的serialization机制实现的是lightweight persistence?因为你必须显式的序列化和反序列化程序里的对象；而不是直接由一个关键词来定义一个对象是序列化的然后由系统做相应的处理。  如果以后的Java版本出现一个新的关键字来实现这种机制，比如就是persistence,如果我用

persistence  (String s="chinaunix")

然后系统自动做上面程序里的那些处理，那么Java就实现了persistence.