Java关键字之transient详解

transient 关键字

tansient是Java中的一个关键字，不过在日常的开发中我们很少用或者是遇到，我也是在
看ArrayList源代码的时候发现其类中声明的一个属性值中用到了transient关键字，表示
这个属性只是暂时的，究竟起到什么作用呢？经过查阅发现transient的功能就是在将一个
对象序列化的时候带transient关键字的属性不会被序列化。下面通过具体的代码来说明这
transient的作用。

 

 

 

package core.java.serializable;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;


public class SerializableDemo {
	
	public static void main(String[] args) {
		SerializableDemo demo = new SerializableDemo();
		System.out.println("开始序列化--------------");
		User user = new User(1, "zhangsan", "男");
		demo.writeObject(user);
		System.out.println("开始反序列化--------------");
		User u = (User)demo.readObject();
		System.out.println(u.getId() + "," + u.getName() + "," + u.getSex());
		
	}
	
	/**
	 * 序列化对象
	 * @param obj
	 */
	private void writeObject(Object obj){
		try {
			ObjectOutputStream ots = new ObjectOutputStream(new FileOutputStream(new File("D:/object.txt")));
			ots.writeObject(obj);
			ots.flush();
			ots.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	
	/**
	 * 反序列化对象
	 * @return
	 */
	private Object readObject(){
		try {
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("D:/object.txt")));
			Object object = ois.readObject();
			ois.close();
			return object;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}


}


package core.java.serializable;


import java.io.Serializable;


/**
 * 序列化实体
 * @author author
 *
 */
public class User implements Serializable{
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 8511909251520938165L;
	private int id;
	private String name;
	private transient String sex;
	
	public User(int id, String name, String sex){
		super();
		this.id = id;
		this.name = name;
		this.sex = sex;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}


}

 

控制台输出：
开始序列化--------------
开始反序列化--------------
1,zhangsan,null

从控制台输出的值我们可以发现User的sex属性值并没有没序列化。

是不是只要是用了transient关键字的属性就不会被序列化呢，其实并不是。我们都
知道要是一个对象实现序列化通过实现Serializable接口就可以，但是还有另外一种方法
实现对象序列化的方式就是实现Externalizable，实现Externalizable接口需要实现该接口
的两个方法writeExternal和readExternal方法，需要手动指定哪些属性将要被实现序列化。
代码演示：

 

 

 

 

 

 

package core.java.serializable;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;


public class SerializableDemo {
	
	public static void main(String[] args) {
		SerializableDemo demo = new SerializableDemo();
		Address address = new Address(1, "中国", "北京", "朝阳区");
		demo.writeObject(address);
		Address add = (Address)demo.readObject();
		System.out.println(add.getId() + "," + add.getCountry() + "," + add.getCity() + "," + add.getArea());
	}
	
	/**
	 * 序列化对象
	 * @param obj
	 */
	private void writeObject(Object obj){
		try {
			ObjectOutputStream ots = new ObjectOutputStream(new FileOutputStream(new File("D:/object.txt")));
			ots.writeObject(obj);
			ots.flush();
			ots.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	
	/**
	 * 反序列化对象
	 * @return
	 */
	private Object readObject(){
		try {
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("D:/object.txt")));
			Object object = ois.readObject();
			ois.close();
			return object;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}


}




package core.java.serializable;


import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;




/**
 * Externalizable方式实现对象序列化
 * @author author
 *
 */
public class Address implements Externalizable{
	
	private int id;
	private String country;
	private String city;
	private transient String area;
	
	public Address(){
		
	}
	
	public Address(int id, String country, String city, String area){
		super();
		this.id = id;
		this.country = country;
		this.city = city;
		this.area = area;
	}


	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		out.writeObject(id);
		out.writeObject(country);
		out.writeObject(city);
		out.writeObject(area);
	}


	@Override
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
		id  = (int) in.readObject();
		country = (String) in.readObject();
		city = (String) in.readObject();
		area = (String) in.readObject();
	}


	public int getId() {
		return id;
	}


	public void setId(int id) {
		this.id = id;
	}


	public String getCountry() {
		return country;
	}


	public void setCountry(String country) {
		this.country = country;
	}


	public String getCity() {
		return city;
	}


	public void setCity(String city) {
		this.city = city;
	}


	public String getArea() {
		return area;
	}


	public void setArea(String area) {
		this.area = area;
	}
	
}

 

 

控制台输出
1,中国,北京,朝阳区

从控制台打印出来的结果可以知道并不是用transient声明的属性就不能被序列化。