java final private_Java反射-修改private final成员变量值

大家都知道使用java反射可以在运行时动态改变对象的行为，甚至是private final的成员变量，但并不是所有情况下，都可以修改成员变量。今天就举几个小例子说明。

首先看下对基本类型的修改:

/***@authorCool-Coding 2018/5/15*/

public classReflectionUsage {private final int age=18;public intgetAge(){returnage;

}}

测试代码:

importjava.lang.reflect.Field;/***@authorCool-Coding 2018/5/15*/

public classReflectionTest {public static voidmain(String[] args){try{

Class reflectionUsage= Class.forName("practise.practise.ReflectionUsage");

ReflectionUsage o=(ReflectionUsage)reflectionUsage.newInstance();

Field age= reflectionUsage.getDeclaredField("age");

age.setAccessible(true);

age.set(o,68);

age.setAccessible(false);

System.out.println(o.getAge());

}catch(ClassNotFoundException e) {

e.printStackTrace();

}catch(NoSuchFieldException e) {

e.printStackTrace();

}catch (IllegalAccessException |InstantiationException e){

}

}

}

运行结果：18

此时无法修改成员变量age.

如果将初始化age放到构造函数中会如何呢:

/***@authorCool-Coding 2018/5/15*/

public classReflectionUsage {private final intage;publicReflectionUsage(){this.age=18;

}public intgetAge(){returnage;

}

}

再执行RefectionTest会发生什么呢?会发现结果变成了68。

为什么会发生这种情形呢？看一下这两个情况下生成的class文件有什么不同：

直接初始化:

public classReflectionUsage {private final int age = 18;publicReflectionUsage() {

}public intgetAge() {return 18;

}

}

构造函数中初始化:

public classReflectionUsage {private final int age = 18;publicReflectionUsage() {

}public intgetAge() {return this.age;

}

}

可以看出如果直接初始化时，经过编译后getAge方法直接返回常量值，而在构造函数中初始化时，返回的是this.age变量的值。

再看下对String类型的修改:

/***@authorCool-Coding 2018/5/15*/

public classReflectionUsage {private final String reflectionString="reflectionString";publicString getReflectionString(){returnreflectionString;

}

}

测试代码:

importjava.lang.reflect.Field;/***@authorCool-Coding 2018/5/15*/

public classReflectionTest {public static voidmain(String[] args){try{

Class reflectionUsage= Class.forName("practise.practise.ReflectionUsage");

ReflectionUsage o=(ReflectionUsage)reflectionUsage.newInstance();

Field reflectionString= reflectionUsage.getDeclaredField("reflectionString");

reflectionString.setAccessible(true);

reflectionString.set(o,"newReflectionString");

reflectionString.setAccessible(false);

System.out.println(o.getReflectionString());

}catch(ClassNotFoundException e) {

e.printStackTrace();

}catch(NoSuchFieldException e) {

e.printStackTrace();

}catch (IllegalAccessException |InstantiationException e){

}

}

}

运行结果:reflectionString

如果将初始化reflectionString放到构造函数中又如何呢?

/***@authorCool-Coding 2018/5/15*/

public classReflectionUsage {private finalString reflectionString;publicReflectionUsage(){this.reflectionString="reflectionString";

}publicString getReflectionString(){returnreflectionString;

}

}

运行结果:newReflectionString

为什么运行结果不同呢，来看下class文件:

直接初始化:

public classReflectionUsage {private final String reflectionString = "reflectionString";publicReflectionUsage() {

}publicString getReflectionString() {return "reflectionString";

}

}

构造函数中初始化:

public classReflectionUsage {private final String reflectionString = "reflectionString";publicReflectionUsage() {

}publicString getReflectionString() {return this.reflectionString;

}

}

可以看出跟基本类型相似，直接初始化时，编译器会将reflectionString出现的地方，替换成常量值，而构造函数中初始化不替换。

再看下对Integer的修改:

/***@authorCool-Coding 2018/5/15*/

public classReflectionUsage {private final Integer age=18;publicInteger getAge(){returnage;

}

}

测试代码:

importjava.lang.reflect.Field;/***@authorCool-Coding 2018/5/15*/

public classReflectionTest {public static voidmain(String[] args){try{

Class reflectionUsage= Class.forName("practise.practise.ReflectionUsage");

ReflectionUsage o=(ReflectionUsage)reflectionUsage.newInstance();

Field reflectionString= reflectionUsage.getDeclaredField("age");

reflectionString.setAccessible(true);

reflectionString.set(o,68);

reflectionString.setAccessible(false);

System.out.println(o.getAge());

}catch(ClassNotFoundException e) {

e.printStackTrace();

}catch(NoSuchFieldException e) {

e.printStackTrace();

}catch (IllegalAccessException |InstantiationException e){

}

}

}

运行结果:68

可以看出直接初始化private final Integer age变量后，不像基本类型和String类型一样不能修改，原因是什么呢，看下class文件。

public classReflectionUsage {private final Integer age = Integer.valueOf(18);publicReflectionUsage() {

}publicInteger getAge() {return this.age;

}

}

可以看到编译器并未将getAge中变量替换成常量。

看到对Integer赋值时，编译器进行了自动装箱，那如果初始化String变量时，使用String.value()方式时，能否被修改呢，来看一下。

/***@authorCool-Coding 2018/5/15*/

public classReflectionUsage {private final String reflectionString = String.valueOf("reflectionString");publicReflectionUsage() {

}publicString getReflectionString() {return this.reflectionString;

}

}

运行结果:newReflectionString

可以看出，reflectionString的值被修改了，看下class文件:

packagepractise.practise;public classReflectionUsage {private final String reflectionString = String.valueOf("reflectionString");publicReflectionUsage() {

}publicString getReflectionString() {return this.reflectionString;

}

}

可见编译器并未替换getReflectionString方法中的变量。

如果在构造函数中初始化Integer类型变量呢?

public classReflectionUsage {private finalInteger age;publicReflectionUsage() {this.age=18;

}publicInteger getAge() {return this.age;

}

}

运行结果:68

age值也被改变了，看下class文件:

public classReflectionUsage {private final Integer age = Integer.valueOf(18);publicReflectionUsage() {

}publicInteger getAge() {return this.age;

}

}

生成的class文件与直接初始化是一样的。

总结:

final可以修改类，变量，方法，表示不可继承，不可修改，不可覆盖(override)，这里讨论了使用反射修改private final修饰的成员变量情况，当private final修改直接初始化的基本类型或String(注意不能使用String.valueOf()初始化)时，使用反射无法修改变量值，其它情况下可以修改。这也告诉我们在平时开发时，如果想定义常量请在基本类型int或String类型前加private final修饰，这样编译器会在编译时将这些变量出现的地方替换成常量，以免被恶意修改。