篡改Java final参数

       在Java语法里， final关键字用在声明参数时， 该参数叫做常量； 否则叫做变量。 

       final关键字的作用是值(或引用)不可改， 但引用的对象可以改值。

常量的一般声明方式：

    class SomeClass {        final int SOME_CONSTANT1 = 1;        final int SOME_CONSTANT2 = 2;                ......    }

        声明时为final参数赋初值， 这种情况下不能篡改。

      但是声明final参数时不赋初值， 这种情况下是可以篡改的！！！ 例如： final int a; a = 1;   可以通过反射修改参数a的值。

      为什么使用关键字后参数就是常量， 不能修改了呢???

  其实final属性以及访问权限都对应一个二进制比特位， 在java.lang.reflect.Modifier.java里声明：

public class Modifier { /**     * The {@code int} value representing the {@code private}     * modifier.     */    public static final int PRIVATE          = 0x00000002;    /**     * The {@code int} value representing the {@code protected}     * modifier.     */    public static final int PROTECTED        = 0x00000004;    /**     * The {@code int} value representing the {@code static}     * modifier.     */    public static final int STATIC           = 0x00000008;    /**     * The {@code int} value representing the {@code final}     * modifier.     */    public static final int FINAL            = 0x00000010;.......}

        那么是否可以篡改函数、属性的访问特性呢？ 答案是肯定的。 下面以修改final属性为例：

  static class Test {        private final int a;  //赋值后仍然可以该        private int b;        private final int c = 3;    //改不了        Test(int param1, int param2) {            a = param1;            b = param2;        }        public int getValueA() {            return a;        }        public int getValueB() {            return b;        }        public int getValueC() { return c; }    }    /**     * 清除final属性， 及修改modifier参数     * @param field     */    public static void removeFieldFinalModifier(final Field field) {        if (field == null) {            return;        }        try {            if (Modifier.isFinal(field.getModifiers())) {                final Field modifiersField = Field.class.getDeclaredField("modifiers");                final boolean doForceAccess = !modifiersField.isAccessible();                if (doForceAccess) {                    modifiersField.setAccessible(true);                }                try {                    modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);                } finally {                    if (doForceAccess) {                        modifiersField.setAccessible(false);                    }                }            }        } catch (final NoSuchFieldException ignored) {            // The field class contains always a modifiers field        } catch (final IllegalAccessException ignored) {            // The modifiers field is made accessible        }    }    public static void main(String[] args) {        Test obj = new Test(1, 2);   //a等于1， b等于2        Class clz = Test.class;        System.out.println("final属性a篡改前：" + obj.getValueA());        System.out.println("非final属性b篡改前：" + obj.getValueB());        System.out.println("final属性c篡改前：" + obj.getValueC());        try {            Field fieldA = clz.getDeclaredField("a");            fieldA.setAccessible(true);            Field fieldB = clz.getDeclaredField("b");            fieldB.setAccessible(true);            Field fieldC = clz.getDeclaredField("c");            fieldC.setAccessible(true);            removeFieldFinalModifier(fieldA);   //删除final限制            fieldA.setInt(obj, 11);  //final属性a的值从1变为11            fieldB.setInt(obj, 22);    //值变为22            removeFieldFinalModifier(fieldC);   //删除final限制            fieldC.setInt(obj, 33);      //无法篡改            System.out.println("---------------以下是结果----------------");            System.out.println("final属性a篡改后：" + obj.getValueA());            System.out.println("非final属性b篡改后：" + obj.getValueB());            System.out.println("final属性c篡改后：" + obj.getValueC());        } catch (Exception ex) {            ex.printStackTrace();        }    }

输出日志：

final属性a篡改前：1
非final属性b篡改前：2
final属性c篡改前：3
---------------以下是结果----------------
final属性a篡改后：11
非final属性b篡改后：22
final属性c篡改后：3