脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java反射 修改private final成员变量值

Java反射如何修改private final成员变量值

 更新时间：2019年07月02日 16:48:21   作者：单行线的旋律  
这篇文章主要介绍了Java反射如何修改private final成员变量值,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

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

基本数据类型

/**
 * @author Cool-Coding 2018/5/15
 */
public class ReflectionUsage {private final int age=18;
 public int getAge(){
  return age;
 }
}

测试代码:

import java.lang.reflect.Field;
/**
 * @author Cool-Coding 2018/5/15
 */
public class ReflectionTest {
 public static void main(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放到构造函数中会如何呢:

/**
 * @author Cool-Coding 2018/5/15
 */
public class ReflectionUsage {private final int age;
 public ReflectionUsage(){
  this.age=18;
 }
 public int getAge(){
  return age;
 }
}

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

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

直接初始化:

public class ReflectionUsage {
 private final int age = 18;
 public ReflectionUsage() {
 }
 public int getAge() {
  return 18;
 }
}

构造函数中初始化:

public class ReflectionUsage {
 private final int age = 18;
 public ReflectionUsage() {
 }
 public int getAge() {
  return this.age;
 }
}

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

String类型

/**
 * @author Cool-Coding 2018/5/15
 */
public class ReflectionUsage {
 private final String reflectionString="reflectionString";
 public String getReflectionString(){
  return reflectionString;
 }
}

测试代码:

import java.lang.reflect.Field;
/**
 * @author Cool-Coding 2018/5/15
 */
public class ReflectionTest {
 public static void main(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放到构造函数中又如何呢?

/**
 * @author Cool-Coding 2018/5/15
 */
public class ReflectionUsage {
 private final String reflectionString;
 public ReflectionUsage(){
  this.reflectionString="reflectionString";
 }
 public String getReflectionString(){
  return reflectionString;
 }
}

运行结果:newReflectionString

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

直接初始化:

public class ReflectionUsage {
 private final String reflectionString = "reflectionString";
 public ReflectionUsage() {
 }
 public String getReflectionString() {
  return "reflectionString";
 }
}

构造函数中初始化:

public class ReflectionUsage {
 private final String reflectionString = "reflectionString";
 public ReflectionUsage() {
 }
 public String getReflectionString() {
  return this.reflectionString;
 }
}

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

Integer类型

/**
 * @author Cool-Coding 2018/5/15
 */
public class ReflectionUsage {
 private final Integer age=18;
 public Integer getAge(){
  return age;
 }
}

测试代码:

import java.lang.reflect.Field;
/**
 * @author Cool-Coding 2018/5/15
 */
public class ReflectionTest {
 public static void main(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 class ReflectionUsage {
 private final Integer age = Integer.valueOf(18);
 public ReflectionUsage() {
 }
 public Integer getAge() {
  return this.age;
 }
}

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

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

/**
 * @author Cool-Coding 2018/5/15
 */
public class ReflectionUsage {
 private final String reflectionString = String.valueOf("reflectionString");
 public ReflectionUsage() {
 }
 public String getReflectionString() {
  return this.reflectionString;
 }
}

运行结果:newReflectionString

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

package practise.practise;
public class ReflectionUsage {
 private final String reflectionString = String.valueOf("reflectionString");
 public ReflectionUsage() {
 }
 public String getReflectionString() {
  return this.reflectionString;
 }
}

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

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

public class ReflectionUsage {
 private final Integer age;
 public ReflectionUsage() {
  this.age=18;
 }
 public Integer getAge() {
  return this.age;
 }
}

运行结果:68

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

public class ReflectionUsage {
 private final Integer age = Integer.valueOf(18);
 public ReflectionUsage() {
 }
 public Integer getAge() {
  return this.age;
 }
}

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

总结:

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

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

您可能感兴趣的文章:

相关文章

  • 浅析Java中Apache BeanUtils和Spring BeanUtils的用法

    浅析Java中Apache BeanUtils和Spring BeanUtils的用法

    这篇文章主要介绍了Java中Apache BeanUtils和Spring BeanUtils的用法,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-11-11
  • Java之MyBatis入门详解

    Java之MyBatis入门详解

    这篇文章主要介绍了Java之MyBatis入门详解，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-12-12
  • Spring 异步接口返回结果的四种方式

    Spring 异步接口返回结果的四种方式

    这篇文章主要介绍了Spring 异步接口返回结果的四种方式，文章围绕主题展开详细的内容介绍，具有一定的参考价值，感兴趣的小伙伴可以参考一下
    2022-08-08
  • 有关IntelliJ IDEA中LeetCode插件配置问题

    有关IntelliJ IDEA中LeetCode插件配置问题

    这篇文章主要介绍了关于IntelliJ IDEA中LeetCode插件配置问题,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-08-08
  • Java陷阱之assert关键字详解

    Java陷阱之assert关键字详解

    这篇文章详细介绍了Java陷阱之assert关键字，有需要的朋友可以参考一下
    2013-09-09
  • Java Swing组件布局管理器之FlowLayout（流式布局）入门教程

    Java Swing组件布局管理器之FlowLayout（流式布局）入门教程

    这篇文章主要介绍了Java Swing组件布局管理器之FlowLayout（流式布局）,结合实例形式分析了Swing组件布局管理器FlowLayout流式布局的常用方法及相关使用技巧,需要的朋友可以参考下
    2017-11-11
  • Java后缀数组之求sa数组的实例代码

    Java后缀数组之求sa数组的实例代码

    后缀数组就是一个字符串所有后缀大小排序后的一个集合，然后我们根据后缀数组的一些性质就可以实现各种需求。这篇文章主要介绍了Java后缀数组-求sa数组,需要的朋友可以参考下
    2018-04-04
  • Java中的Runnable，Callable，Future，FutureTask的比较

    Java中的Runnable，Callable，Future，FutureTask的比较

    这篇文章主要介绍了Java中的Runnable，Callable，Future，FutureTask的比较的相关资料,需要的朋友可以参考下
    2017-02-02
  • Spring事务aftercommit原理及实践

    Spring事务aftercommit原理及实践

    这篇文章主要为大家介绍了Spring事务aftercommit原理及实践,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-09-09
  • 一文彻底掌握RocketMQ 的存储模型

    一文彻底掌握RocketMQ 的存储模型

    这篇文章主要介绍了RocketMQ 的存储模型,本文的重点在于分析 BrokerServer 的消息存储模型，笔者按照自己的理解 , 尝试分析 RocketMQ 的存储模型，需要的朋友可以参考下
    2022-12-12

最新评论