*
     * @param clazz
     *            クラス。{@literal null}であってはいけません
     * @return <code>abstract</code>なら{@literal true}
     */
    public static boolean isAbstract(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        return isAbstract(clazz.getModifiers());
    }

    /**
     * <code>abstract</code>かどうか返します。
     *
     * @param modifier
     *            モディファイヤ

        assertFalse(ModifierUtil.isTransient(f));
    }

    /**
     * @throws Exception
     */
    public void testIsAbstract() throws Exception {
        assertTrue(ModifierUtil.isAbstract(Map.class));
        assertFalse(ModifierUtil.isAbstract(HashMap.class));
    }

    /**
     *
     */
    public static class Hoge {

        /**
         *
         */
        public static final String s = null;

        assertThat(foo.getParameterTypes().length, is(0));
        assertThat(foo.isPublic(), is(true));
        assertThat(foo.isStatic(), is(not(true)));
        assertThat(foo.isFinal(), is(not(true)));
        assertThat(foo.isAbstract(), is(not(true)));
        assertThat(foo.invoke(new MyBean()), is((Object) "hoge"));
    }

    /**
     * @throws Exception
     */
    @Test(expected = MethodNotStaticRuntimeException.class)

    assertFalse(invokable.isAbstract());
    assertFalse(invokable.isStatic());
    assertTrue(invokable.isAnnotationPresent(Tested.class));
  }

  public void testAbstractMethod() throws Exception {
    Invokable<?, Object> invokable = A.method("abstractMethod");
    assertTrue(invokable.isPackagePrivate());
    assertTrue(invokable.isAbstract());
    assertFalse(invokable.isFinal());

    assertFalse(invokable.isAbstract());
    assertFalse(invokable.isStatic());
    assertTrue(invokable.isAnnotationPresent(Tested.class));
  }

  public void testAbstractMethod() throws Exception {
    Invokable<?, Object> invokable = A.method("abstractMethod");
    assertTrue(invokable.isPackagePrivate());
    assertTrue(invokable.isAbstract());
    assertFalse(invokable.isFinal());

    }

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

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

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

        String appWebPkg = ".app.web.";
        String actionSuffix = "Action";

        // ## Act ##
        policeStoryOfJavaClassChase((srcFile, clazz) -> {
            if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) { // e.g. BaseAction
                return;
            }
            final String className = clazz.getName();
            if (className.contains(appWebPkg) && className.endsWith(actionSuffix)) {

    internal
    val isIncubating: Boolean
        get() = delegate.visibleAnnotations.has(incubatingAnnotationTypeDescriptor)

    val isSAM: Boolean by unsafeLazy {
        delegate.access.isAbstract && singleAbstractMethodOf(delegate)?.access?.isPublic == true
    }

    val typeParameters: List<ApiTypeUsage> by unsafeLazy {
        context.apiTypeParametersFor(visitedSignature)
    }

     *
     * @param method
     *            メソッド。{@literal null}であってはいけません
     * @return <code>abstract</code>かどうか
     */
    public static boolean isAbstract(final Method method) {
        return Modifier.isAbstract(method.getModifiers());
    }

    /**
     * <code>public</code>かどうかを返します。
     *
     * @param method
     *            メソッド。{@literal null}であってはいけません

    for (Method method : methods) {
      // Under java 8, interfaces can have default methods that aren't abstract.
      // No need to verify them.
      // Can't check isDefault() for JDK 7 compatibility.
      if (!Modifier.isAbstract(method.getModifiers())) {
        continue;
      }
      // The interface could be package-private or private.
      // filter out equals/hashCode/toString
      if (method.getName().equals("equals")