transient关键字小结

1.transient关键字

　在对象序列化时使用，用来修饰不想被序列化的属性。不能用来修饰类和方法,静态变量不管是否被修饰都不能被序列化。

　

public class User implements Serializable{
    
    /**
     * 测试用
     */
    private static final long serialVersionUID = -2156547593289371682L;

    private static String userName;
    
    private transient Integer age;
    
    private int weight;
    
    private transient static String gender;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    

    
}

public class MyTest {
    
    @Test
    public void transientTest(){
        User user=new User();
        user.setUserName("cc");
        user.setAge(16);
        user.setWeight(100);
        user.setGender("man");
        System.out.println("userName"+user.getUserName());
        System.out.println("age:"+user.getAge());
        System.out.println("weight:"+user.getWeight());
        System.out.println("gender"+user.getGender());
        System.out.println("----------");
        try {
            ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:/user.txt"));
            /**将对象写入文件*/
            oos.writeObject(user);
            oos.flush();
            oos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:/user.txt"));
            user=(User)ois.readObject();
            ois.close();
            System.out.println("userName:"+user.getUserName());
            /**age字段添加了tansient后不被写入序列化文件*/
            System.out.println("age:"+user.getAge());
            System.out.println("weight:"+user.getWeight());
            System.out.println("gender:"+user.getGender());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

测试结果：

　　

　　

　　只有weight属性被序列化了，控制台中输出的静态变量全是当前JVM中变量对应的值.

　　

public class ExternalizableTest implements Externalizable{
    
    private transient String test="序列化啦！！！";
    
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(test);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        test=(String)in.readObject();
    }
    
    public static void main(String[] args) {
        ExternalizableTest et=new ExternalizableTest();
        try {
            ObjectOutput oo=new ObjectOutputStream(new FileOutputStream("e:/exTest.txt"));
            oo.writeObject(et);
            ObjectInput oi=new ObjectInputStream(new FileInputStream("e:/exTest.txt"));
            et=(ExternalizableTest) oi.readObject();
            System.out.println(et.test);
            oo.close();
            oi.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    
    

}

　　若实现的是Externalizable接口，则没有任何东西可以自动序列化，需要在writeExternal方法中进行手工指定所要序列化的变量，这与是否被transient修饰无关。因此第二个例子输出的是变量content初始化的内容，而不是null。