trainsent java_java关键字tranisent用法详解

作为java中的一个关键字，tranisent用的并不是很多，但是在某些关键场合，却又起着极为重要的作用，因此有必要对它进行一些必要的了解。

一、定义：声明不用序列化的成员域。(源自百度百科)

二、作用：根据tranisent关键字的定义，我们可以很容易的归纳出它的作用，那就是修饰变量，使之不能成为对象持久化的一部分，当然，对于tranisent修饰的这个变量，也是有要求的，这个变量不能是本地变量，如果是用户自定义的变量，那么拥有这个变量的类必须实现Serializable接口；根据之前对static和final的描述，我们知道它们除了可以修饰变量之外，还可以修饰方法和类，但是对于tranisent来说，它有且仅有可以修饰变量的作用，对于方法和类，它是不允许修饰的。

1.修饰变量：对于tranisent修饰的变量，是不允许被序列化的。

importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.ObjectInputStream;importjava.io.ObjectOutputStream;importjava.io.Serializable;public class Rectangle implementsSerializable {

private static final long serialVersionUID = 1710022455003682613L;privateInteger width;privateInteger height;private transientInteger area;publicRectangle (Integer width, Integer height){this.width =width;this.height =height;this.area = width *height;

}public voidsetArea(){this.area = this.width * this.height;

}

@OverridepublicString toString(){

StringBuffer sb= new StringBuffer(40);

sb.append("width : ");

sb.append(this.width);

sb.append("\nheight : ");

sb.append(this.height);

sb.append("\narea : ");

sb.append(this.area);returnsb.toString();

}

}public classTransientExample {public static void main(String args[]) throwsException {

Rectangle rectangle= new Rectangle(3,4);

System.out.println("1.原始对象\n"+rectangle);

ObjectOutputStream o= new ObjectOutputStream(new FileOutputStream("rectangle"));//往流写入对象

o.writeObject(rectangle);

o.close();//从流读取对象

ObjectInputStream in = new ObjectInputStream(new FileInputStream("rectangle"));

Rectangle rectangle1=(Rectangle)in.readObject();

System.out.println("2.反序列化后的对象\n"+rectangle1);

rectangle1.setArea();

System.out.println("3.恢复成原始对象\n"+rectangle1);

in.close();

}

}

输出结果：

1.原始对象

width :3height :4area :12

2.反序列化后的对象

width :3height :4area :null

3.恢复成原始对象

width :3height :4area :12

注：被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

那么又会产生一个新的问题，是否被transient关键字修饰的变量真的就不能被序列化呢？

importjava.io.Externalizable;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.ObjectInput;importjava.io.ObjectInputStream;importjava.io.ObjectOutput;importjava.io.ObjectOutputStream;public class Person implementsExternalizable {private transient String content = "是的，我会被序列化";

@Overridepublic void writeExternal(ObjectOutput out) throwsIOException {

out.writeObject(content);

}

@Overridepublic void readExternal(ObjectInput in) throwsIOException,

ClassNotFoundException {

content=(String) in.readObject();

}public static void main(String[] args) throwsException {

Person person= newPerson();

ObjectOutput out= new ObjectOutputStream(newFileOutputStream(new File("test")));

out.writeObject(person);

ObjectInput in= new ObjectInputStream(new FileInputStream(newFile("test")));

person=(Person) in.readObject();

System.out.println(person.content);

out.close();

in.close();

}

}

输出结果：

是的，我会被序列化

十分意外的是，被transient关键字修饰的变量竟然也可以序列化了，这又是为什么呢？原来之前我们所说的，全都是建立在该类是实现Serializable接口的，但是我们知道，在java中，对象的序列化是可以通过两种接口来实现的，一个是Serializable接口，另一个就是上图中所展示的Externalizable接口，至于二者的具体区别，这里不详细诉说了，但是实现Serializable接口，所有的序列化都是自动进行的，实现Externalizable接口则不同，需要我们在writeExternal方法中进行手动序列化，因此这个时候transient就不能够起到什么作用了，这也是为什么在上面的例子中变量content能够被序列化的原因。

总结：虽然transient关键字不是那么常用，但是却不代表它不重要，这里我就简单的小结了一下，如果大家还有什么好的建议，欢迎在评论区留言。