protected AccessibleObject() 
{

}

Constructor: only used by the Java Virtual Machine.

  void checkAccess(Class<?> caller,
    Class<?> clazz,
    Object obj,
    int modifiers) throws IllegalAccessException 
{
        if (caller == clazz) {  // quick check
            return;             // ACCESS IS OK
        }
        Object cache = securityCheckCache;  // read volatile
        Class< ? > targetClass = clazz;
        if (obj != null
            && Modifier.isProtected(modifiers)
            && ((targetClass = obj.getClass()) != clazz)) {
            // Must match a 2-list of { caller, targetClass }.
            if (cache instanceof Class[]) {
                Class< ? >[] cache2 = (Class< ? >[]) cache;
                if (cache2[1] == targetClass &&
                    cache2[0] == caller) {
                    return;     // ACCESS IS OK
                }
                // (Test cache[1] first since range check for [1]
                // subsumes range check for [0].)
            }
        } else if (cache == caller) {
            // Non-protected case (or obj.class == this.clazz).
            return;             // ACCESS IS OK
        }
        // If no return, fall through to the slow path.
        slowCheckMemberAccess(caller, clazz, obj, modifiers, targetClass);
}

 public T getAnnotation(Class<T> annotationClass) 
{
        throw new AssertionError("All subclasses should override this method");
}

 public Annotation[] getAnnotations() 
{
        return getDeclaredAnnotations();
}

 public Annotation[] getDeclaredAnnotations() 
{
        throw new AssertionError("All subclasses should override this method");
}

 public boolean isAccessible() 
{
        return override;
}

Get the value of the {@code accessible} flag for this object.

 public boolean isAnnotationPresent(Class<Annotation> annotationClass) 
{
        return getAnnotation(annotationClass) != null;
}

 public  void setAccessible(boolean flag) throws SecurityException 
{
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
        setAccessible0(this, flag);
}

Set the {@code accessible} flag for this object to the indicated boolean value. A value of {@code true} indicates that the reflected object should suppress Java language access checking when it is used. A value of {@code false} indicates that the reflected object should enforce Java language access checks.

First, if there is a security manager, its {@code checkPermission} method is called with a {@code ReflectPermission("suppressAccessChecks")} permission.

A {@code SecurityException} is raised if {@code flag} is {@code true} but accessibility of this object may not be changed (for example, if this element object is a Constructor object for the class java.lang.Class ).

A {@code SecurityException} is raised if this object is a java.lang.reflect.Constructor object for the class {@code java.lang.Class}, and {@code flag} is true.

 public static  void setAccessible(AccessibleObject[] array,
    boolean flag) throws SecurityException 
{
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
        for (int i = 0; i <  array.length; i++) {
            setAccessible0(array[i], flag);
        }
}

Convenience method to set the {@code accessible} flag for an array of objects with a single security check (for efficiency).

First, if there is a security manager, its {@code checkPermission} method is called with a {@code ReflectPermission("suppressAccessChecks")} permission.

A {@code SecurityException} is raised if {@code flag} is {@code true} but accessibility of any of the elements of the input {@code array} may not be changed (for example, if the element object is a Constructor object for the class java.lang.Class ). In the event of such a SecurityException, the accessibility of objects is set to {@code flag} for array elements upto (and excluding) the element for which the exception occurred; the accessibility of elements beyond (and including) the element for which the exception occurred is unchanged.

  void slowCheckMemberAccess(Class<?> caller,
    Class<?> clazz,
    Object obj,
    int modifiers,
    Class<?> targetClass) throws IllegalAccessException 
{
        Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);
        // Success: Update the cache.
        Object cache = ((targetClass == clazz)
                        ? caller
                        : new Class< ? >[] { caller, targetClass });
        // Note:  The two cache elements are not volatile,
        // but they are effectively final.  The Java memory model
        // guarantees that the initializing stores for the cache
        // elements will occur before the volatile write.
        securityCheckCache = cache;         // write volatile
}