I found a way and it worked on JDK 8, 11, 17.

Method getDeclaredFields0 = Class.class.getDeclaredMethod("getDeclaredFields0", boolean.class);
getDeclaredFields0.setAccessible(true);
Field[] fields = (Field[]) getDeclaredFields0.invoke(Field.class, false);
Field modifiers = null;
for (Field each : fields) {
    if ("modifiers".equals(each.getName())) {
        modifiers = each;
        break;
    }
}
assertNotNull(modifiers);

Don't forget to set the following args when using JDK 11 or higher:

--add-opens java.base/java.lang=ALL-UNNAMED --add-opens java.base/java.lang.reflect=ALL-UNNAMED

You can't. This was a change done on purpose.

For example, you could use PowerMock and it's @PrepareForTest - under the hood it uses javassist (bytecode manipulation) if you want to use that for testing purposes. This is exactly what that bug in the comments suggests to do.

In other words, since java-12 - there is no way to access that via vanilla java.

This works in JDK 17.

import java.lang.reflect.Field;
import sun.misc.Unsafe;

/**
 * @author Arnah
 * @since Feb 21, 2021
 **/
public class FieldUtil{

    private static Unsafe unsafe;

    static{
        try{
            final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
            unsafeField.setAccessible(true);
            unsafe = (Unsafe) unsafeField.get(null);
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }

    public static void setFinalStatic(Field field, Object value) throws Exception{
        Object fieldBase = unsafe.staticFieldBase(field);
        long fieldOffset = unsafe.staticFieldOffset(field);

        unsafe.putObject(fieldBase, fieldOffset, value);
    }
}

public class YourClass{
    public static final int MAX_ITEM_ROWS = 35_000;
}

FieldUtil.setFinalStatic(YourClass.class.getDeclaredField("MAX_ITEM_ROWS"), 1);

It is possible without java.misc.Unsafe on Java 21 with the following Code and JVM parameters:

JVM-Parameters:

--add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-exports=java.base/java.lang.invoke=ALL-UNNAMED --add-exports=java.base/jdk.internal.access=ALL-UNNAMED --add-exports=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-exports=jdk.unsupported/sun.misc=ALL-UNNAMED

Java-Code

public class HiddenFieldsRevealed {

    private static final Object greeting = "Hello world";

    public static void main(String... args) throws Throwable {

        Field myStaticFinalField = HiddenFieldsRevealed.class.getDeclaredField("greeting");
        myStaticFinalField.setAccessible(true);

        removeFinalness(myStaticFinalField);

        //Logic taken from java.lang.invoke.MethodHandle.unreflectSetter(Field)
        
        //.unreflectSetter(Field) 
        //=> .unreflectField(Field, false)
        //=> lookup.getDirectFieldNoSecurityManager(memberName.getReferenceKind(), f.getDeclaringClass(), memberName);
        //=> .getDirectFieldCommon(refKind, referenceClass, memberName, false)
        
        Class<?> memberNameClass = Class.forName("java.lang.invoke.MemberName");
        
        Constructor<?> memberNameConstructor = memberNameClass.getDeclaredConstructor(Field.class, boolean.class);
        memberNameConstructor.setAccessible(true);

        Object memberNameInstanceForField = memberNameConstructor.newInstance(myStaticFinalField, true);
        
        Field memberNameFlagsField = memberNameClass.getDeclaredField("flags");
        
        memberNameFlagsField.setAccessible(true);
        
        //Manipulate flags to remove hints to it being final
        memberNameFlagsField.setInt(memberNameInstanceForField, (int)memberNameFlagsField.getInt(memberNameInstanceForField) & ~Modifier.FINAL);
        
        Method getReferenceKindMethod = memberNameClass.getDeclaredMethod("getReferenceKind");
        
        getReferenceKindMethod.setAccessible(true);
        
        byte getReferenceKind = (byte)getReferenceKindMethod.invoke(memberNameInstanceForField);

        MethodHandles.Lookup mh = MethodHandles.privateLookupIn(HiddenFieldsRevealed.class, MethodHandles.lookup());

        Method getDirectFieldCommonMethod = mh.getClass().getDeclaredMethod("getDirectFieldCommon", byte.class, Class.class, memberNameClass, boolean.class);
        
        getDirectFieldCommonMethod.setAccessible(true);
        
        //Invoke last method to obtain the method handle

        MethodHandle o = (MethodHandle) getDirectFieldCommonMethod.invoke(mh, getReferenceKind, myStaticFinalField.getDeclaringClass(), memberNameInstanceForField, false);
        
        o.invoke("ModifiedValue");

        System.out.println(greeting);

    }

    public static void removeFinalness(Field field) throws Throwable {
        Method[] classMethods = Class.class.getDeclaredMethods();

        Method declaredFieldMethod = Arrays.stream(classMethods).filter(x -> Objects.equals(x.getName(), "getDeclaredFields0")).findAny().orElseThrow();

        declaredFieldMethod.setAccessible(true);

        Field[] declaredFieldsOfField = (Field[]) declaredFieldMethod.invoke(Field.class, false);

        Field modifiersField = Arrays.stream(declaredFieldsOfField).filter(x -> Objects.equals(x.getName(), "modifiers")).findAny().orElseThrow();

        modifiersField.setAccessible(true);

        modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);

    }
}

As of Java 21 this works because of the direct call to getDirectFieldCommon(...) that we can fool by modifying the flags on MemberName instance for a field.

Considering that Unsafe.getStaticFieldOffset(...) is deprecated and this workaround is prone to break, I hope that there will be always a way in the future to modify static final fields at runtime because there are some nasty dependencies that are easier to deal with this way than to have the whole ordeal of writing something that instruments the class or to patch the library on compile with a build system just to remove a final where it should not have been in the first place.