Java反射-修改private final成員變量值

大家都知道使用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;
    }
}

 

可見編譯器並未替換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修飾，這樣編譯器會在編譯時將這些變量出現的地方替換成常量，以免被惡意修改。