说一说java关键字final和transient

2019-11-26 14:10:06

字体：大中小

来源：转载

供稿：网友

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

参考文章：//www.VeVB.COm/article/86996.htm

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

上一篇：Java中的BufferedInputStream与BufferedOutputStream使用示例

下一篇：java web验证码实现代码分享