说一说java关键字final和transient

说一说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接口的类，tTJyyIwnea没有任何东西可以自动序列化，无论是否使用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编程思想》第四版

参考文章：//jb51.net/article/86996.htm

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。