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

其他 2018-07-25 03:22:17 阅读次数: 0

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

　　基本数据类型

　　String类型

　　Integer类型

　　总结

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

复制代码

/**
 * @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;
    }
}

复制代码

以下代码与本文无关，请自行跳过

<P><A href="http://www.zzchanghong110.com/"><FONT color=#ffffff>郑州检查男科疾病去哪家医院</FONT>
<P><A href="http://www.zztj120.com/"><FONT color=#ffffff>郑州妇科在线咨询</FONT>
<P><A href="http://www.ytsgnk.com/"><FONT color=#ffffff>郑州看男科多少钱</FONT>
<P><A href="http://www.zzfkyy120.com/"><FONT color=#ffffff>郑州不孕不育正规医院</FONT>

可见编译器并未替换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修饰，这样编译器会在编译时将这些变量出现的地方替换成常量，以免被恶意修改。

猜你喜欢

转载自blog.csdn.net/qq_42564846/article/details/81178707
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022