这篇文章主要围绕Java反射如何修改privatefinal成员变量值和java反射修改方法内容展开，旨在为您提供一份详细的参考资料。我们将全面介绍Java反射如何修改privatefinal成员变量

这篇文章主要围绕Java反射如何修改private final成员变量值和java反射修改方法内容展开，旨在为您提供一份详细的参考资料。我们将全面介绍Java反射如何修改private final成员变量值的优缺点，解答java反射修改方法内容的相关问题，同时也会为您带来Android-Java-静态成员变量&成员变量&局部变量(内存图&回收机制)、c – 有什么办法可以访问类的Private成员变量吗？、final修饰成员变量和局部变量的区别，static修饰成员变量、java final修饰的成员变量需要立即初始化的实用方法。

• Java反射如何修改private final成员变量值（java反射修改方法内容）
• Android-Java-静态成员变量&成员变量&局部变量(内存图&回收机制)
• c – 有什么办法可以访问类的Private成员变量吗？
• final修饰成员变量和局部变量的区别，static修饰成员变量
• java final修饰的成员变量需要立即初始化

Java反射如何修改private final成员变量值（java反射修改方法内容）

这篇文章主要介绍了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修饰，这样编译器会在编译时将这些变量出现的地方替换成常量，以免被恶意修改。

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

Android-Java-静态成员变量&成员变量&局部变量(内存图&回收机制)

静态成员变量（回收机制）

StaticDemo 和 MyDemo

package android.java.oop13;

class MyDemo {

    /**
     * 定义一个静态变量
     */
    public static String country = "中国";

}

public class StaticDemo {

    public static void main(String[] args) {

        /**
         * 能够使用 类名.静态成员变量，是因为静态成员变量是存放在（方法区(数据共享区) 的 静态区中）
         * 属于共享数据，不需要实例化对象，直接拿类名访问静态成员变量即可
         */
        System.out.println("country:" + MyDemo.country);

    }

}

执行结果：

 对应以上案例的内存图：

回收机制：

　　静态成员变量的回收机制是：随着类的加载而加载，随着类的消失而消失，由于类需要非常长时间的不使用，不利用，不关联，才有可能会被回收机制回收，

所以静态成员变量的生命周期特别长，除非是共享数据，否则不建议使用静态；

成员变量：

Demo 与 DemoTest

package android.java.oop13;

class Demo {

    /**
     * 定义一个普通成员变量name
     */
    public String name;

    // 定义此方法就是为了打印name
    public void showName() {
        System.out.println(this.name);
    }

}

public class DemoTest {

    public static void main(String[] args) {

        Demo demo = new Demo();

        demo.name = "许文强";

        demo.showName();

    }

}

执行结果：

以上案例对应内存图：

 回收机制：

　　成员变量：是随着对象的实例化而存在，随着对象的回收而消亡，所以比静态成员变量生命周期要短一些，建议非共享数据，定义成 成员变量；

局部变量：

Demo 与 DemoTest：

package android.java.oop13;

class Demo {

    public void showName() {

        /**
         * 定义局部变量
         */
        String name = "谢晓峰";

        System.out.println(name);
    }

}

public class DemoTest2 {

    public static void main(String[] args) {

        Demo demo = new Demo();

        demo.showName();

    }

}

执行结果：

以上案例对应的内存图：

回收机制：

　　　局部变量：局部变量的回收机制 生命周期 现对于 静态成员变量/成员变量/ 来说是最短的；

　　　因为 方法一旦弹栈/出栈 此局部变量就会被回收了；

c – 有什么办法可以访问类的Private成员变量吗？

class Bla
{
public:
    Bla() : x(15),str("bla") {}
private:
    int x;
    std::string str;
}

int main()
{
    Bla bla;

    int x = *((int*)(&bla));
    std::string str = *((std::string*)((int*)(&bla) + 1));

    std::cout << x << str;

    return 0;
}

final修饰成员变量和局部变量的区别，static修饰成员变量

当fianl修饰成员变量的时候一定要初始化，当修饰局部变量的时候，可以先只定义（blank fianl）

static表示共享当static修饰成员变量的时候，如果一个方法对该static变量改变了值，那么以后的对象后该变量的值为多少

结果如下：2 3 3 3 3 

java final修饰的成员变量需要立即初始化

我们今天的关于Java反射如何修改private final成员变量值和java反射修改方法内容的分享已经告一段落，感谢您的关注，如果您想了解更多关于Android-Java-静态成员变量&成员变量&局部变量(内存图&回收机制)、c – 有什么办法可以访问类的Private成员变量吗？、final修饰成员变量和局部变量的区别，static修饰成员变量、java final修饰的成员变量需要立即初始化的相关信息，请在本站查询。