为什么无法访问公共静态方法？

Question

I'm trying to reflect the parse(CharSequence, DateTimeFormatter) methods from classes which each extends the TemporalAccessor class.

    private static final Map<Class<?>, MethodHandle> PARSE_HANDLES = synchronizedMap(new HashMap<>());

    static <T extends TemporalAccessor> MethodHandle parseMethodHandle(final Class<T> clazz) {
        if (clazz == null) {
            throw new NullPointerException("clazz is null");
        }
        return PARSE_HANDLES.computeIfAbsent(clazz, k -> {
            try {
                final Method method = clazz.getMethod("parse", CharSequence.class, DateTimeFormatter.class);
                log.debug("method: {}, {}", method, method.isAccessible());
                // i don't understand; public static method is not accessible? yet it isn't.
                assert method.isAccessible(); // NOT GOOD with UTs
                return MethodHandles.lookup().unreflect(method);
            } catch (final ReflectiveOperationException roe) {
                throw new RuntimeException(roe);
            }
        });
    }

With the YearMonth class, I got this.

method: public static java.time.YearMonth java.time.YearMonth.parse(java.lang.CharSequence,java.time.format.DateTimeFormatter), false

Why a public static method is not accessible?

Answer 1

See the documentation for isAccessible :

This method is deprecated because its name hints that it checks if the reflected object is accessible when it actually indicates if the checks for Java language access control are suppressed. This method may return false on a reflected object that is accessible to the caller. To test if this reflected object is accessible, it should use canAccess(Object) .

(My emphasis.)

Answer 2

With the Java Reflection API, you can override the accessibility of methods by setting the accessible flag. This can be performed by method.setAccessible(true) .

Now the isAccessible() method does not what you think it does, but it simply checks, if the standard java access checks are currently overridden.

This means, that you can of course invoke the method with reflection if the standard access modifiers allow it. Otherwise, you had to set the accessible flag.