asaskevich / MainSandBox.java
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters
| package sandbox ; |
| import java . lang . reflect . Field ; |
| import java . lang . reflect . Modifier ; |
| public class MainSandBox |
| public static void main ( String [] args ) throws Exception |
| Example ex = new Example (); |
| // Change private modifier to public |
| Field f = ex . getClass (). getDeclaredField ( «id» ); |
| f . setAccessible ( true ); |
| // Remove final modifier |
| Field modifiersField = Field . class . getDeclaredField ( «modifiers» ); |
| modifiersField . setAccessible ( true ); |
| modifiersField . setInt ( f , f . getModifiers () & ~ Modifier . FINAL ); |
| // Get and set field value |
| Integer old_value = ( Integer ) f . get ( ex ); |
| f . set ( ex , 20 ); |
| Integer new_value = ( Integer ) f . get ( ex ); |
| // OUTPUT |
| System . out . println ( «ex1: \n » + old_value + » \n » + new_value ); |
| Example ex2 = new Example (); |
| Field f2 = ex2 . getClass (). getDeclaredField ( «id» ); |
| f2 . setAccessible ( true ); |
| // Get and set field value |
| Integer old_value_2 = ( Integer ) f2 . get ( ex2 ); |
| System . out . println ( «ex2: \n » + old_value_2 ); |
| > |
| > |
| class Example |
| private final int id = 10 ; |
| > |
Изменение приватного статического финального поля с помощью Java Reflection
В Java, когда поле объявлено как private static final, это означает, что оно может быть установлено только один раз и не может быть изменено после его инициализации.
В Java, когда поле объявлено как private static final , это означает, что оно может быть установлено только один раз и не может быть изменено после его инициализации. Однако, иногда возникает необходимость изменить это поле во время выполнения программы. Одним из способов это сделать является использование Java Reflection.
Предположим, у нас есть класс MyClass с private static final полем MY_CONST :
Попытка изменить MY_CONST напрямую вызовет ошибку компиляции, поскольку это поле объявлено как final .
MyClass.MY_CONST = "New Value"; // Ошибка компиляции
Вместо этого, можно использовать Java Reflection для обхода этого ограничения. Ниже приведен код, который показывает, как это можно сделать:
Field field = MyClass.class.getDeclaredField("MY_CONST"); field.setAccessible(true); Field modifiersField = Field.class.getDeclaredField("modifiers"); modifiersField.setAccessible(true); modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL); field.set(null, "New Value"); Таким образом, первые две строки получают ссылку на поле MY_CONST и делают его доступным. Следующие две строки убирают модификатор final у поля. В последней строке устанавливается новое значение для MY_CONST .
Однако, стоит отметить, что использование Java Reflection для изменения private static final полей — это плохая практика, которую следует избегать. Это может привести к неожиданным и труднообнаруживаемым ошибкам, нарушает принципы инкапсуляции и может нарушить безопасность. Этот метод следует использовать только в крайних случаях, когда нет других решений.
asaskevich / MainSandBox.java
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters
| package sandbox ; |
| import java . lang . reflect . Field ; |
| import java . lang . reflect . Modifier ; |
| public class MainSandBox |
| public static void main ( String [] args ) throws Exception |
| Example ex = new Example (); |
| // Change private modifier to public |
| Field f = ex . getClass (). getDeclaredField ( «id» ); |
| f . setAccessible ( true ); |
| // Remove final modifier |
| Field modifiersField = Field . class . getDeclaredField ( «modifiers» ); |
| modifiersField . setAccessible ( true ); |
| modifiersField . setInt ( f , f . getModifiers () & ~ Modifier . FINAL ); |
| // Get and set field value |
| Integer old_value = ( Integer ) f . get ( ex ); |
| f . set ( ex , 20 ); |
| Integer new_value = ( Integer ) f . get ( ex ); |
| // OUTPUT |
| System . out . println ( «ex1: \n » + old_value + » \n » + new_value ); |
| Example ex2 = new Example (); |
| Field f2 = ex2 . getClass (). getDeclaredField ( «id» ); |
| f2 . setAccessible ( true ); |
| // Get and set field value |
| Integer old_value_2 = ( Integer ) f2 . get ( ex2 ); |
| System . out . println ( «ex2: \n » + old_value_2 ); |
| > |
| > |
| class Example |
| private final int id = 10 ; |
| > |
Change private static final field using Java reflection
Also I fixed an issue with override which the previous solutions seem to miss. However use this very carefully, only when there’s no other good solution.
Assuming no SecurityManager is preventing you from doing this, you can use setAccessible to get around private and resetting the modifier to get rid of final , and actually modify a private static final field.
import java.lang.reflect.*; public class EverythingIsTrue < static void setFinalStatic(Field field, Object newValue) throws Exception < field.setAccessible(true); Field modifiersField = Field.class.getDeclaredField("modifiers"); modifiersField.setAccessible(true); modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL); field.set(null, newValue); >public static void main(String args[]) throws Exception < setFinalStatic(Boolean.class.getField("FALSE"), true); System.out.format("Everything is %s", false); // "Everything is true" >> Assuming no SecurityException is thrown, the above code prints «Everything is true» .
What’s actually done here is as follows:
- The primitive boolean values true and false in main are autoboxed to reference type Boolean «constants» Boolean.TRUE and Boolean.FALSE
- Reflection is used to change the public static final Boolean.FALSE to refer to the Boolean referred to by Boolean.TRUE
- As a result, subsequently whenever a false is autoboxed to Boolean.FALSE , it refers to the same Boolean as the one refered to by Boolean.TRUE
- Everything that was «false» now is «true»
Related questions
- Using reflection to change static final File.separatorChar for unit testing
- How to limit setAccessible to only “legitimate” uses?
- Has examples of messing with Integer ‘s cache, mutating a String , etc
Caveats
Extreme care should be taken whenever you do something like this. It may not work because a SecurityManager may be present, but even if it doesn’t, depending on usage pattern, it may or may not work.
JLS 17.5.3 Subsequent Modification of Final Fields
In some cases, such as deserialization, the system will need to change the final fields of an object after construction. final fields can be changed via reflection and other implementation dependent means. The only pattern in which this has reasonable semantics is one in which an object is constructed and then the final fields of the object are updated. The object should not be made visible to other threads, nor should the final fields be read, until all updates to the final fields of the object are complete. Freezes of a final field occur both at the end of the constructor in which the final field is set, and immediately after each modification of a final field via reflection or other special mechanism.
Even then, there are a number of complications. If a final field is initialized to a compile-time constant in the field declaration, changes to the final field may not be observed, since uses of that final field are replaced at compile time with the compile-time constant.
Another problem is that the specification allows aggressive optimization of final fields. Within a thread, it is permissible to reorder reads of a final field with those modifications of a final field that do not take place in the constructor.
See also
- JLS 15.28 Constant Expression
- It’s unlikely that this technique works with a primitive private static final boolean , because it’s inlineable as a compile-time constant and thus the «new» value may not be observable
Appendix: On the bitwise manipulation
field.getModifiers() & ~Modifier.FINALturns off the bit corresponding to Modifier.FINAL from field.getModifiers() . & is the bitwise-and, and ~ is the bitwise-complement.
See also
Remember Constant Expressions
Still not being able to solve this?, have fallen onto depression like I did for it? Does your code looks like this?
Reading the comments on this answer, specially the one by @Pshemo, it reminded me that Constant Expressions are handled different so it will be impossible to modify it. Hence you will need to change your code to look like this:
if you are not the owner of the class. I feel you!
For more details about why this behavior read this?
If the value assigned to a static final boolean field is known at compile-time, it is a constant. Fields of primitive or String type can be compile-time constants. A constant will be inlined in any code that references the field. Since the field is not actually read at runtime, changing it then will have no effect.
The Java language specification says this:
If a field is a constant variable (§4.12.4), then deleting the keyword final or changing its value will not break compatibility with pre-existing binaries by causing them not to run, but they will not see any new value for the usage of the field unless they are recompiled. This is true even if the usage itself is not a compile-time constant expression (§15.28)
If you decompile Checker , you’ll see that instead of referencing Flag.FLAG , the code simply pushes a value of 1 ( true ) onto the stack (instruction #3).
0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream; 3: iconst_1 4: invokevirtual #3; //Method java/io/PrintStream.println:(Z)V 7: returnA little curiosity from the Java Language Specification, chapter 17, section 17.5.4 «Write-protected Fields»:
Normally, a field that is final and static may not be modified. However, System.in, System.out, and System.err are static final fields that, for legacy reasons, must be allowed to be changed by the methods System.setIn, System.setOut, and System.setErr. We refer to these fields as being write-protected to distinguish them from ordinary final fields.