疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

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();

  }

  }

  }

  声明: