return isPublic(modifier) && isStatic(modifier) && isFinal(modifier);
    }

    /**
     * Checks if the specified modifier is public.
     *
     * @param modifier
     *            the modifier to check
     * @return true if public, false otherwise
     */
    public static boolean isPublic(final int modifier) {
        return Modifier.isPublic(modifier);
    }

    /**

  }

  return CacheControl(
    noCache = noCache,
    noStore = noStore,
    maxAgeSeconds = maxAgeSeconds,
    sMaxAgeSeconds = sMaxAgeSeconds,
    isPrivate = isPrivate,
    isPublic = isPublic,
    mustRevalidate = mustRevalidate,
    maxStaleSeconds = maxStaleSeconds,
    minFreshSeconds = minFreshSeconds,
    onlyIfCached = onlyIfCached,
    noTransform = noTransform,
    immutable = immutable,

     * @return whether the constructor is <code>public</code>
     */
    public static boolean isPublic(final Constructor<?> constructor) {
        assertArgumentNotNull("constructor", constructor);

        return Modifier.isPublic(constructor.getModifiers());
    }

  public final boolean isPublic() {
    return Modifier.isPublic(getModifiers());
  }

  /** Returns true if the element is protected. */
  public final boolean isProtected() {
    return Modifier.isProtected(getModifiers());
  }

  /** Returns true if the element is package-private. */
  public final boolean isPackagePrivate() {
    return !isPrivate() && !isPublic() && !isProtected();
  }

        return (Constructor<T>) constructor;
    }

    @Override
    public Class<?>[] getParameterTypes() {
        return parameterTypes;
    }

    @Override
    public boolean isPublic() {
        return ConstructorUtil.isPublic(constructor);
    }

    @Override
    public boolean isParameterized(final int index) {
        assertArgumentArrayIndex("index", index, parameterTypes.length);

    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> Class<T> getReturnType() {
        return (Class<T>) returnType;
    }

    @Override
    public boolean isPublic() {
        return MethodUtil.isPublic(method);
    }

    @Override
    public boolean isStatic() {
        return MethodUtil.isStatic(method);
    }

    @Override
    public boolean isFinal() {

    Class<?>[] getParameterTypes();

    /**
     * Returns {@literal true} if the constructor is {@literal public}.
     *
     * @return {@literal true} if the constructor is {@literal public}
     */
    boolean isPublic();

    /**
     * Returns {@literal true} if the parameter type of the constructor is parameterized.
     *
     * @param index
     *            The index of the parameter

     */
    <T> Class<T> getFieldType();

    /**
     * Returns {@literal true} if the field is {@literal public}.
     *
     * @return {@literal true} if the field is {@literal public}
     */
    boolean isPublic();

    /**
     * Returns {@literal true} if the field is {@literal static}.
     *
     * @return {@literal true} if the field is {@literal static}
     */
    boolean isStatic();

    /**

        return fieldName;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> Class<T> getFieldType() {
        return (Class<T>) fieldType;
    }

    @Override
    public boolean isPublic() {
        return FieldUtil.isPublicField(field);
    }

    @Override
    public boolean isStatic() {
        return !FieldUtil.isInstanceField(field);
    }

    @Override

     */
    <T> Class<T> getReturnType();

    /**
     * Returns {@literal true} if the method is {@literal public}.
     *
     * @return {@literal true} if the method is {@literal public}
     */
    boolean isPublic();

    /**
     * Returns {@literal true} if the method is {@literal static}.
     *
     * @return {@literal true} if the method is {@literal static}
     */
    boolean isStatic();

    /**