Java Code Examples for java.lang.reflect.Modifier#isAbstract()

/**
 * Finds public constructor
 * that is declared in public class.
 *
 * @param type  the class that can have constructor
 * @param args  parameter types that is used to find constructor
 * @return object that represents found constructor
 * @throws NoSuchMethodException if constructor could not be found
 *                               or some constructors are found
 */
public static Constructor<?> findConstructor(Class<?> type, Class<?>...args) throws NoSuchMethodException {
    if (type.isPrimitive()) {
        throw new NoSuchMethodException("Primitive wrapper does not contain constructors");
    }
    if (type.isInterface()) {
        throw new NoSuchMethodException("Interface does not contain constructors");
    }
    if (Modifier.isAbstract(type.getModifiers())) {
        throw new NoSuchMethodException("Abstract class cannot be instantiated");
    }
    if (!Modifier.isPublic(type.getModifiers()) || !isPackageAccessible(type)) {
        throw new NoSuchMethodException("Class is not accessible");
    }
    PrimitiveWrapperMap.replacePrimitivesWithWrappers(args);
    Signature signature = new Signature(type, args);

    try {
        return CACHE.get(signature);
    }
    catch (SignatureException exception) {
        throw exception.toNoSuchMethodException("Constructor is not found");
    }
}
 

private boolean shouldExpose(Method method) {
	boolean isUserDefined = !method.getDeclaringClass().equals(Object.class);

	int modifiers = method.getModifiers();

	boolean isAbstract = Modifier.isAbstract(modifiers);
	boolean isStatic = Modifier.isStatic(modifiers);
	boolean isPrivate = Modifier.isPrivate(modifiers);
	boolean isProtected = Modifier.isProtected(modifiers);

	if (isUserDefined && !isAbstract && !isStatic && !isPrivate && !isProtected && method.getAnnotations().length > 0) {
		for (Annotation ann : method.getAnnotations()) {
			String annoName = ann.annotationType().getName();
			if (CONTROLLER_ANNOTATIONS.contains(annoName)) {
				return true;
			}
		}
	}

	return false;
}
 

private void generateSuperMethods() {
    for(final MethodInfo mi: methodInfos) {
        if(!Modifier.isAbstract(mi.method.getModifiers())) {
            generateSuperMethod(mi);
        }
    }
}
 

private static boolean hasCommitCorrection(@NonNull final Class clazz) {
    try {
        final Method method = clazz.getMethod("commitCorrection", CorrectionInfo.class);
        return !Modifier.isAbstract(method.getModifiers());
    } catch (NoSuchMethodException e) {
        return false;
    }
}
 

/**
 * Returns check methods to run as tests using java reflection.
 * The following rules are applied to select check methods:
 * <ul>
 *   <li>methods declared in this class or inherited from super class</li>
 *   <li>methods with modifier 'public' or 'protected', but not 'abstract'</li>
 *   <li>methods that starts with <code>check</code></li>
 * </ul>
 * @return a list of check methods.
 */
private List<Method> getCheckMethods(PortletRequest request) {
    List<Method> checkMethods = new ArrayList<Method>();
    DefaultTestPhase dtp = getClass().getAnnotation(DefaultTestPhase.class);
    String defaultPhase = dtp != null ? dtp.value() 
                                      : PortletRequest.RENDER_PHASE;
    String lifecyclePhase = (String) 
            request.getAttribute(PortletRequest.LIFECYCLE_PHASE);
    debugWithName("Default phase: " + defaultPhase);
    debugWithName("Lifecycle Phase: " + lifecyclePhase);
    for (Class<?> clazz = getClass();
            clazz != null && AbstractReflectivePortletTest.class.isAssignableFrom(clazz);
            clazz = clazz.getSuperclass()) {
        // debugWithName("Checking class: " + clazz.getName());
        Method[] methods = clazz.getDeclaredMethods();
        String phase;
        TestPhase testPhase;
        for (int i = 0; i < methods.length; i++) {
            int mod = methods[i].getModifiers();
            testPhase = methods[i].getAnnotation(TestPhase.class);
            phase = testPhase != null ? testPhase.value() : defaultPhase;
            if ((Modifier.isPublic(mod) || Modifier.isProtected(mod))
                   && lifecyclePhase.equals(phase)
                   && !Modifier.isAbstract(mod)
                   && methods[i].getName().startsWith("check")) {
                // debugWithName(" - got check method: " + methods[i].getName());
                debugWithName(" - got check method: " + methods[i].getName());
                checkMethods.add(methods[i]);
            }
        }
    }
    return checkMethods;
}
 

/**
 * Returns a direct MethodHandle for the {@code writeReplace} method on
 * a serializable class.
 * The single argument of {@link MethodHandle#invoke} is the serializable
 * object.
 *
 * @param cl the Serializable class
 * @return  a direct MethodHandle for the {@code writeReplace} method of the class or
 *          {@code null} if the class does not have a {@code writeReplace} method
 */
private MethodHandle getReplaceResolveForSerialization(Class<?> cl,
                                                       String methodName) {
    if (!Serializable.class.isAssignableFrom(cl)) {
        return null;
    }

    Class<?> defCl = cl;
    while (defCl != null) {
        try {
            Method m = defCl.getDeclaredMethod(methodName);
            if (m.getReturnType() != Object.class) {
                return null;
            }
            int mods = m.getModifiers();
            if (Modifier.isStatic(mods) | Modifier.isAbstract(mods)) {
                return null;
            } else if (Modifier.isPublic(mods) | Modifier.isProtected(mods)) {
                // fall through
            } else if (Modifier.isPrivate(mods) && (cl != defCl)) {
                return null;
            } else if (!packageEquals(cl, defCl)) {
                return null;
            }
            try {
                // Normal return
                m.setAccessible(true);
                return MethodHandles.lookup().unreflect(m);
            } catch (IllegalAccessException ex0) {
                // setAccessible should prevent IAE
                throw new InternalError("Error", ex0);
            }
        } catch (NoSuchMethodException ex) {
            defCl = defCl.getSuperclass();
        }
    }
    return null;
}
 

@Override
public T createInstance() {
	if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) {
		return null;
	}
	try {
		T t = clazz.newInstance();
		initializeFields(t);
		return t;
	}
	catch (Exception e) {
		throw new RuntimeException("Cannot instantiate class.", e);
	}
}
 

@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
  check(invocation);
  //call only non-abstract real method 
  if (Modifier.isAbstract(invocation.getMethod().getModifiers())) {
    return null;
  } else {
    return invocation.callRealMethod();
  }
}
 

public static Set<Class<? extends ObjectPayload>> getPayloadClasses () {
    final Reflections reflections = new Reflections(ObjectPayload.class.getPackage().getName());
    final Set<Class<? extends ObjectPayload>> payloadTypes = reflections.getSubTypesOf(ObjectPayload.class);
    for ( Iterator<Class<? extends ObjectPayload>> iterator = payloadTypes.iterator(); iterator.hasNext(); ) {
        Class<? extends ObjectPayload> pc = iterator.next();
        if ( pc.isInterface() || Modifier.isAbstract(pc.getModifiers()) ) {
            iterator.remove();
        }
    }
    return payloadTypes;
}
 

/**
 * @see DynamicFinderServicesImpl#getConcreteJavaType
 */
private JavaType getConcreteJavaType(final MemberDetails memberDetails) {
    Validate.notNull(memberDetails, "Member details required");
    JavaType javaType = null;
    for (final MemberHoldingTypeDetails memberHoldingTypeDetails : memberDetails
            .getDetails()) {
        if (Modifier.isAbstract(memberHoldingTypeDetails.getModifier())) {
            continue;
        }
        javaType = memberHoldingTypeDetails.getName();
    }
    return javaType;
}
 

public boolean isAbstract() {
    return Modifier.isAbstract(modifiers);
}
 

/**
 * Create instance of <code>mapClass</code> from JSON representation. If
 * <code>mapClass</code> is interface then appropriate implementation of
 * interface will be returned.
 *
 * @param mapClass
 *         map type
 * @param genericType
 *         actual type of map
 * @param jsonObject
 *         source JSON object
 * @return map
 * @throws JsonException
 *         if any errors occurs
 */
@SuppressWarnings("unchecked")
public static <T extends Map<String, ?>> T createObject(Class<T> mapClass, Type genericType, JsonValue jsonObject)
        throws JsonException {
    if (jsonObject == null || jsonObject.isNull()) {
        return null;
    }
    Class mapValueClass;
    Type mapValueType;
    if (genericType instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType)genericType;
        if (!String.class.isAssignableFrom((Class)parameterizedType.getActualTypeArguments()[0])) {
            throw new JsonException("Key of Map must be String. ");
        }
        mapValueType = parameterizedType.getActualTypeArguments()[1];
        if (mapValueType instanceof Class) {
            mapValueClass = (Class)mapValueType;
        } else if (mapValueType instanceof ParameterizedType) {
            mapValueClass = (Class)((ParameterizedType)mapValueType).getRawType();
        } else {
            throw new JsonException(
                    String.format("This type of Map can't be restored from JSON source.\nMap is parameterized by wrong Type: %s",
                                  parameterizedType));
        }
    } else {
        throw new JsonException("Map is not parameterized. Map<Sting, ?> is not supported.");
    }
    Constructor<? extends T> constructor;
    if (mapClass.isInterface() || Modifier.isAbstract(mapClass.getModifiers())) {
        constructor = getConstructor(findAcceptableMapImplementation(mapClass), Map.class);
    } else {
        constructor = getConstructor(mapClass, Map.class);
    }

    Types jsonMapValueType = getType(mapValueClass);
    HashMap<String, Object> sourceMap = new HashMap<>(jsonObject.size());
    Iterator<String> keys = jsonObject.getKeys();
    while (keys.hasNext()) {
        String key = keys.next();
        JsonValue childJsonValue = jsonObject.getElement(key);
        if (jsonMapValueType == null) {
            sourceMap.put(key, createObject(mapValueClass, childJsonValue));
        } else {
            switch (jsonMapValueType) {
                case BYTE:
                case SHORT:
                case INT:
                case LONG:
                case FLOAT:
                case DOUBLE:
                case BOOLEAN:
                case CHAR:
                case STRING:
                case NULL:
                case ARRAY_BYTE:
                case ARRAY_SHORT:
                case ARRAY_INT:
                case ARRAY_LONG:
                case ARRAY_FLOAT:
                case ARRAY_DOUBLE:
                case ARRAY_BOOLEAN:
                case ARRAY_CHAR:
                case ARRAY_STRING:
                case CLASS:
                    sourceMap.put(key, createObjectKnownTypes(mapValueClass, childJsonValue));
                    break;
                case ARRAY_OBJECT:
                    sourceMap.put(key, createArray(mapValueClass, childJsonValue));
                    break;
                case COLLECTION:
                    sourceMap.put(key, createCollection(mapValueClass, mapValueType, childJsonValue));
                    break;
                case MAP:
                    sourceMap.put(key, createObject(mapValueClass, mapValueType, childJsonValue));
                    break;
                case ENUM:
                    sourceMap.put(key, createEnum(mapValueClass, childJsonValue));
                    break;
            }
        }
    }
    try {
        return constructor.newInstance(sourceMap);
    } catch (Exception e) {
        throw new JsonException(e.getMessage(), e);
    }
}
 

/**
 * Gathers methods that can be implemented or overridden from the specified type into this factory's
 * {@link #methodInfos} set. It will add all non-final, non-static methods that are either public or protected from
 * the type if the type itself is public. If the type is a class, the method will recursively invoke itself for its
 * superclass and the interfaces it implements, and add further methods that were not directly declared on the
 * class.
 * @param type the type defining the methods.
 */
private void gatherMethods(final Class<?> type) throws AdaptationException {
    if (Modifier.isPublic(type.getModifiers())) {
        final Method[] typeMethods = type.isInterface() ? type.getMethods() : type.getDeclaredMethods();

        for (final Method typeMethod: typeMethods) {
            final String name = typeMethod.getName();
            if(name.startsWith(SUPER_PREFIX)) {
                continue;
            }
            final int m = typeMethod.getModifiers();
            if (Modifier.isStatic(m)) {
                continue;
            }
            if (Modifier.isPublic(m) || Modifier.isProtected(m)) {
                // Is it a "finalize()"?
                if(name.equals("finalize") && typeMethod.getParameterCount() == 0) {
                    if(type != Object.class) {
                        hasExplicitFinalizer = true;
                        if(Modifier.isFinal(m)) {
                            // Must be able to override an explicit finalizer
                            throw new AdaptationException(Outcome.ERROR_FINAL_FINALIZER, type.getCanonicalName());
                        }
                    }
                    continue;
                }

                final MethodInfo mi = new MethodInfo(typeMethod);
                if (Modifier.isFinal(m) || isCallerSensitive(typeMethod)) {
                    finalMethods.add(mi);
                } else if (!finalMethods.contains(mi) && methodInfos.add(mi)) {
                    if (Modifier.isAbstract(m)) {
                        abstractMethodNames.add(mi.getName());
                    }
                    mi.setIsCanonical(this);
                }
            }
        }
    }
    // If the type is a class, visit its superclasses and declared interfaces. If it's an interface, we're done.
    // Needing to invoke the method recursively for a non-interface Class object is the consequence of needing to
    // see all declared protected methods, and Class.getDeclaredMethods() doesn't provide those declared in a
    // superclass. For interfaces, we used Class.getMethods(), as we're only interested in public ones there, and
    // getMethods() does provide those declared in a superinterface.
    if (!type.isInterface()) {
        final Class<?> superType = type.getSuperclass();
        if (superType != null) {
            gatherMethods(superType);
        }
        for (final Class<?> itf: type.getInterfaces()) {
            gatherMethods(itf);
        }
    }
}
 

/**
 * Return true if this class is abstract
 */
public boolean isAbstract() {
    return Modifier.isAbstract(getModifiers());
}
 

private static boolean isAbstract(Class<?> clazz) {
  return Modifier.isAbstract(clazz.getModifiers());
}
 

/** Utility method to query the modifier flags of this member. */
public boolean isAbstract() {
    return Modifier.isAbstract(flags);
}
 

@Override
public boolean isAbstract() {
	return Modifier.isAbstract(this.introspectedClass.getModifiers());
}
 

public boolean isAbstract(Class clazz) {
    return Modifier.isAbstract(clazz.getModifiers());
}
 

@Override
public boolean isAbstract() {
	return Modifier.isAbstract(this.introspectedClass.getModifiers());
}
 

/**
 * Checks if a method is abstract
 *
 * @param method
 *
 * @return
 */
public static boolean isAbstract(Method method) {
    return Modifier.isAbstract(method.getModifiers());
}