transient关键字在Java中的使用

熟悉Java关键字transient，必须认真地理解下列几点：

1. transient关键字只修饰对象的成员变量，不能修饰本地变量或者方法。

2. transient修饰的变量不能被序列化。（注意，static修饰的静态变量，不管是否有transient修饰都不能序列化）

3. 类中的成员变量被transient修饰不能作为实例对象序列化数据的一部分，不能够被其访问。

下面的例子很好的说明了这一点：

package org.IO;

import java.io.*;
import java.util.Date;

/**
 * Author: JohnLiu
 */
public class SerializableOperation implements java.io.Serializable {

    private static final long serialVersionUID = -5836283489677344417L;

    public transient int intValue = 10;
    public transient Date now = new Date();
    public transient static int staticIntValue = 2;
    public static void  main(String []args) throws IOException, ClassNotFoundException {
        SerializableOperation operation = new SerializableOperation();
        operation.intValue = 11;
        SerializableOperation.staticIntValue = 1;
        ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(
                                                new File("0xcc00"))) ;
        output.writeObject(operation);
        output.close();

        ObjectInputStream input = new ObjectInputStream(new FileInputStream(new File("0xcc00")));
        SerializableOperation operationStream = (SerializableOperation)input.readObject();
        input.close();

        System.out.println("read from serializable oject.\n  intValue:" + operationStream.intValue);
        System.out.println(" now date:" + operationStream.now);
        /**
         * 结果：
         * read from serializable oject.
         *intValue:0
         *now date:null
         */
    }

}

另一个例子中，你也许会感到奇怪：

package org.IO;

import java.io.*;

/**
 * Author: JohnLiu
 */
public class ExternalizableOperation implements Externalizable {
    private transient String content = "Externalizable序列化我的，并且是指定序列化的，不管我是是否被transient关键字修饰";

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(content);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        content = (String) in.readObject();
    }

    public static void main(String[] args) throws Exception {
        ExternalizableOperation et = new ExternalizableOperation();
        ObjectOutput output = new ObjectOutputStream(new FileOutputStream(
                new File("eternalizableFile")));
        output.writeObject(et);
        output.close();

        ObjectInput input = new ObjectInputStream(new FileInputStream(new File(
                "eternalizableFile")));
        ExternalizableOperation externalizableOperation = (ExternalizableOperation) input.readObject();
        System.out.println(externalizableOperation.content);
        input.close();
        /**
         * 结果：
         *   Externalizable序列化我的，并且是指定序列化的，不管我是是否被transient关键字修饰
         */
    }
}

你不是说，transient修饰的变量不能被序列化吗？
好吧，可以这样解释：
对象的序列化可以通过实现两种接口来实现，一个是Serializable对象，则所有的序列化将会自动进行；另一个是Externalizable对象，则没有任何东西可以自动序列化，需要实现在writeExternal和readExternal方法来进行手工指定所要序列化的变量，而这个操作与transient修饰无关。