How to use

isStatic

method

in

java.lang.reflect.Modifier

@Override
public boolean isStatic() {
  return Modifier.isStatic(this.introspectedMethod.getModifiers());
}

/**
 * Determine if the supplied class is an <em>inner class</em>,
 * i.e. a non-static member of an enclosing class.
 * @return {@code true} if the supplied class is an inner class
 * @since 5.0.5
 * @see Class#isMemberClass()
 */
public static boolean isInnerClass(Class<?> clazz) {
  return (clazz.isMemberClass() && !Modifier.isStatic(clazz.getModifiers()));
}

/**
 * Determine whether the given field is a "public static final" constant.
 * @param field the field to check
 */
public static boolean isPublicStaticFinal(Field field) {
  int modifiers = field.getModifiers();
  return (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers));
}

@Override
protected boolean isCandidateForInvocation(Method method, Class<?> targetClass) {
  if (Modifier.isStatic(method.getModifiers())) {
    return false;
  }
  Class<?> clazz = method.getDeclaringClass();
  return (clazz != Object.class && clazz != Class.class && !ClassLoader.class.isAssignableFrom(targetClass));
}

private static boolean isStaticNonPrivateAndNonFinal(Class<?> clazz) {
  Assert.notNull(clazz, "Class must not be null");
  int modifiers = clazz.getModifiers();
  return (Modifier.isStatic(modifiers) && !Modifier.isPrivate(modifiers) && !Modifier.isFinal(modifiers));
}

public static boolean isPublicInstanceField(Field field) {
  return Modifier.isPublic(field.getModifiers())
      && !Modifier.isStatic(field.getModifiers())
      && !Modifier.isFinal(field.getModifiers())
      && !field.isSynthetic();
}

public static boolean isPublicInstanceField(Field field) {
  return Modifier.isPublic(field.getModifiers())
      && !Modifier.isStatic(field.getModifiers())
      && !Modifier.isFinal(field.getModifiers())
      && !field.isSynthetic();
}

public static boolean isCandidateWriteMethod(Method method) {
  String methodName = method.getName();
  Class<?>[] parameterTypes = method.getParameterTypes();
  int nParams = parameterTypes.length;
  return (methodName.length() > 3 && methodName.startsWith("set") && Modifier.isPublic(method.getModifiers()) &&
      (!void.class.isAssignableFrom(method.getReturnType()) || Modifier.isStatic(method.getModifiers())) &&
      (nParams == 1 || (nParams == 2 && int.class == parameterTypes[0])));
}

public static boolean isBeanPropertyWriteMethod(Method method) {
  return method != null
      && Modifier.isPublic(method.getModifiers())
      && !Modifier.isStatic(method.getModifiers())
      && method.getDeclaringClass() != Object.class
      && method.getParameterTypes().length == 1
      && method.getName().startsWith("set")
      && method.getName().length() > 3;
}

public static boolean isBeanPropertyWriteMethod(Method method) {
  return method != null
      && Modifier.isPublic(method.getModifiers())
      && !Modifier.isStatic(method.getModifiers())
      && method.getDeclaringClass() != Object.class
      && method.getParameterTypes().length == 1
      && method.getName().startsWith("set")
      && method.getName().length() > 3;
}

public static boolean isBeanPropertyReadMethod(Method method) {
  return method != null
      && Modifier.isPublic(method.getModifiers())
      && !Modifier.isStatic(method.getModifiers())
      && method.getReturnType() != void.class
      && method.getDeclaringClass() != Object.class
      && method.getParameterTypes().length == 0
      && ((method.getName().startsWith("get") && method.getName().length() > 3)
      || (method.getName().startsWith("is") && method.getName().length() > 2));
}

public static boolean isBeanPropertyReadMethod(Method method) {
  return method != null
      && Modifier.isPublic(method.getModifiers())
      && !Modifier.isStatic(method.getModifiers())
      && method.getReturnType() != void.class
      && method.getDeclaringClass() != Object.class
      && method.getParameterTypes().length == 0
      && ((method.getName().startsWith("get") && method.getName().length() > 3)
      || (method.getName().startsWith("is") && method.getName().length() > 2));
}

@Override
public boolean isIndependent() {
  return (!hasEnclosingClass() ||
      (this.introspectedClass.getDeclaringClass() != null &&
          Modifier.isStatic(this.introspectedClass.getModifiers())));
}

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

@Nullable
private static Method determineToMethod(Class<?> targetClass, Class<?> sourceClass) {
  if (String.class == targetClass || String.class == sourceClass) {
    // Do not accept a toString() method or any to methods on String itself
    return null;
  }
  Method method = ClassUtils.getMethodIfAvailable(sourceClass, "to" + targetClass.getSimpleName());
  return (method != null && !Modifier.isStatic(method.getModifiers()) &&
      ClassUtils.isAssignable(targetClass, method.getReturnType()) ? method : null);
}

  @Override
  public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
    Reference reference = getAnnotation(field, Reference.class);
    if (reference != null) {
      if (Modifier.isStatic(field.getModifiers())) {
        if (logger.isWarnEnabled()) {
          logger.warn("@Reference annotation is not supported on static fields: " + field);
        }
        return;
      }
      elements.add(new ReferenceFieldElement(field, reference));
    }
  }
});

private void eagerlyValidateMethods(Class<?> service) {
 Platform platform = Platform.get();
 for (Method method : service.getDeclaredMethods()) {
  if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
   loadServiceMethod(method);
  }
 }
}

 @Override
 public boolean apply(Field input) {
  int modifiers = input.getModifiers();
  return isPublic(modifiers)
    && isStatic(modifiers)
    && isFinal(modifiers)
    && MediaType.class.equals(input.getType());
 }
});

private static Set<MethodSignature> getPublicStaticMethods(Class<?> clazz) {
 Set<MethodSignature> publicStaticMethods = newHashSet();
 for (Method method : clazz.getDeclaredMethods()) {
  int modifiers = method.getModifiers();
  if (isPublic(modifiers) && isStatic(modifiers)) {
   publicStaticMethods.add(new MethodSignature(method));
  }
 }
 return publicStaticMethods;
}

private static void doTestMocking(RateLimiter mock) throws Exception {
 for (Method method : RateLimiter.class.getMethods()) {
  if (!isStatic(method.getModifiers())
    && !NOT_WORKING_ON_MOCKS.contains(method.getName())
    && !method.getDeclaringClass().equals(Object.class)) {
   method.invoke(mock, arbitraryParameters(method));
  }
 }
}