说一说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编程思想》第四版

参考文章：

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。