java关键字---final和transient

首先，说说final。

final关键字可以修饰变量，方法，类。

   final变量：

        需求：

            1 需要一个永不改变的编译时常量

            2 一个运行时被初始化的值，不希望被更改

        好处：

           编译时就执行的计算，减轻运行时的负担

        扩展：

           可以修饰基本类型和引用对象。修饰基本类型的时候，表示数值很定不变。修饰对象引用的时候，一旦引用被初始化指向一个对象，就无法再将它更改指向另一个对象（该对象本身是可以修改的）

        空白final

           final修饰但又没有给出初始值的域

           必须在域的的定义或构造器内用表达式给final赋值（final使用前必须初始化）

       注意：

          如果一个对象被static和final同时修饰（编译期常量），一般用大写表示，下划线链接单词

       修饰参数：

          如果final修饰参数，表示该参数可读，但无法修改。

      用法示例：

private Random rand=new Random();
	private static  Random random=new Random();
	private final int n1=12;
	private final int number=rand.nextInt(30);
	private  static final int NUMBER2=random.nextInt(40);
	@Test
	public void finalDataTest(){
		System.out.println(n1);
		System.out.println("--------------------");
		System.out.println(rand.nextInt(30));
		System.out.println("--------------------");
		System.out.println("编译初始之后，不会改变："+number);
		System.out.println("--------------------");
		System.out.println("编译初始之后，不会改变："+NUMBER2);

	}
	/**
	 * final修饰参数：该参数可读，但无法修改。
	 * @param sk
	 * @return
	 */
	public String finalParam(final String sk){
		//sk="jeyson"; final参数不能被修改
		return sk;

	}　

 

    final方法：

       final也可以修饰方法，表示该方法不能被子类继承。

       使用final的好处：

         1 JDK1.5以前，效率更高，JDK1.5以后可以忽略

         2 方法锁定，确保子类中该方法含义不变，不能被覆盖

    用法示例：

 public final String finalMethod(){
             return "Hello World" ;
      }

　　

   final类：

     不希望被任何类继承，可以使用final修饰类

    用法示例：

  public final class FinalClassTx {
   private int k ;

   public void getMyWord(){
         System. out .println("这是一个final类，k的值是" +getK());
   }

public int getK() {
       return k ;
}
public void setK( int k) {
       this .k = k;
}

}

　然后 transient关键字：

　

   transient只能修饰变量，表示该变量不能被序列化。

   一般我们继承Serializable接口的类，序列化会自动进行，使用transient修饰的变量在该类被序列化的时候，不会序列化到指定目的地。

   所以，

     1 被transient修饰的变量不再是对象持久化的一部分，该变量内容序列化无法获得访问

     2 transient只能修饰变量，不能修饰方法和类

     3 一个静态变量无论是否被transient修饰，都不能被序列化

   用法示例：

public class TransientEx  {

	public static void main(String[] args) {
		User user=new User();
		user.setUsername("jeyson");
		user.setPassword("123456");
		System.out.println("序列化前：");
		System.out.println("   username="+user.getUsername());
		System.out.println("   password="+user.getPassword());
		//序列化
		try {
			ObjectOutputStream os=new ObjectOutputStream(new FileOutputStream("C://MyResource//test1.txt"));
			os.writeObject(user);
			os.flush();
			os.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		//反序列化
		try {

			ObjectInputStream is=new ObjectInputStream(new FileInputStream("C://MyResource//test1.txt"));
			user=(User) is.readObject();
			is.close();
			System.out.println("序列化后：");
			System.out.println("   username="+user.getUsername());
			System.out.println("   password="+user.getPassword());

		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("--------------------------------");

	}
}

class User implements Serializable{

	private static final long serialVersionUID = 1L;

	private  String username;
	//使用 transient
	private transient String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}	

}

　　扩展：Externalizable

实现了serializable接口的类，所以序列化会自动进行

       实现了Externaliazble接口的类，没有任何东西可以自动序列化，无论是否使用transient对结果都没有影响。

        此时如果需要序列化，需要在writeExternal方法中上进行手动指定所要序列化的变量。

     使用示例：

public class ExternalizableEx implements Externalizable {
	private transient String name="ssss";

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

	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public static void main(String[] args) {
		 ExternalizableEx ex=new ExternalizableEx();
		 ex.setName("jeyson");
		 System.out.println("Externalizable序列化前:");
		 System.out.println(ex.getName());
		 //序列化
		 try {
			 ObjectOutputStream os=new ObjectOutputStream(new FileOutputStream(new File("C://MyResource//test2.txt")));
			 os.writeObject(ex);
			 os.flush();
			 os.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		 //反序列化
		 try {
			 ObjectInputStream is=new ObjectInputStream(new FileInputStream(new File("C://MyResource//test2.txt")));
			 ex=(ExternalizableEx) is.readObject();
			 is.close();
			 System.out.println("Externalizable序列化后:");
			 System.out.println(ex.getName());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

　声明：

final大部分来自《java编程思想》第四版

transient相关部分参考自：http://www.cnblogs.com/lanxuezaipiao/p/3369962.html