Java Modifier.isPrivate方法代码示例

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
/**
 * Check utility class well defined: is final, has only one private constructor and all methods are static
 * @param clazz Class to check
 */
public static void checkUtilityClass(final Class<?> clazz) {
	try {
		Assert.assertTrue("class must be final", Modifier.isFinal(clazz.getModifiers()));
		Assert.assertEquals("There must be only one constructor", 1, clazz.getDeclaredConstructors().length);
		final Constructor<?> constructor = clazz.getDeclaredConstructor();
		if (constructor.isAccessible() || !Modifier.isPrivate(constructor.getModifiers())) {
			Assert.fail("constructor is not private");
		}
		constructor.setAccessible(true);
		constructor.newInstance();
		constructor.setAccessible(false);
		for (final Method method : clazz.getMethods()) {
			if (!Modifier.isStatic(method.getModifiers()) && method.getDeclaringClass().equals(clazz)) {
				Assert.fail("there exists a non-static method:" + method);
			}
		}
	} catch (SecurityException | NoSuchMethodException | InstantiationException | IllegalAccessException
			| IllegalArgumentException | InvocationTargetException e) {
		throw new RuntimeException(e);
	}
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
private Symbol.MethodSymbol mostAccessible( Symbol.MethodSymbol ctor, Symbol.MethodSymbol sym )
{
  int ctorMods = (int)ctor.flags();
  int symMods = (int)sym.flags();
  if( Modifier.isPublic( ctorMods ) )
  {
    return ctor;
  }
  if( Modifier.isPublic( symMods ) )
  {
    return sym;
  }
  if( Modifier.isProtected( ctorMods ) )
  {
    return ctor;
  }
  if( Modifier.isProtected( symMods ) )
  {
    return sym;
  }
  if( Modifier.isPrivate( ctorMods ) )
  {
    return Modifier.isPrivate( symMods ) ? ctor : sym;
  }
  return ctor;
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
String accessFailedMessage(Class<?> refc, MemberName m) {
    Class<?> defc = m.getDeclaringClass();
    int mods = m.getModifiers();
    // check the class first:
    boolean classOK = (Modifier.isPublic(defc.getModifiers()) &&
                       (defc == refc ||
                        Modifier.isPublic(refc.getModifiers())));
    if (!classOK && (allowedModes & PACKAGE) != 0) {
        classOK = (VerifyAccess.isClassAccessible(defc, lookupClass(), FULL_POWER_MODES) &&
                   (defc == refc ||
                    VerifyAccess.isClassAccessible(refc, lookupClass(), FULL_POWER_MODES)));
    }
    if (!classOK)
        return "class is not public";
    if (Modifier.isPublic(mods))
        return "access to public member failed";  // (how?, module not readable?)
    if (Modifier.isPrivate(mods))
        return "member is private";
    if (Modifier.isProtected(mods))
        return "member is protected";
    return "member is private to package";
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
/**
 * Lookup readResolve or writeReplace on a class with specified
 * signature constraints.
 * @param cl a serializable class
 * @param methodName the method name to find
 * @returns a MethodHandle for the method or {@code null} if not found or
 *       has the wrong signature.
 */
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;
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
private void validateClass(Class<?> source, RuleSourceValidationProblemCollector problems) {
    int modifiers = source.getModifiers();

    if (Modifier.isInterface(modifiers)) {
        problems.add("Must be a class, not an interface");
    }

    if (source.getEnclosingClass() != null) {
        if (Modifier.isStatic(modifiers)) {
            if (Modifier.isPrivate(modifiers)) {
                problems.add("Class cannot be private");
            }
        } else {
            problems.add("Enclosed classes must be static and non private");
        }
    }

    Constructor<?>[] constructors = source.getDeclaredConstructors();
    for (Constructor<?> constructor : constructors) {
        if (constructor.getParameterTypes().length > 0) {
            problems.add("Cannot declare a constructor that takes arguments");
            break;
        }
    }

    Field[] fields = source.getDeclaredFields();
    for (Field field : fields) {
        int fieldModifiers = field.getModifiers();
        if (!field.isSynthetic() && !(Modifier.isStatic(fieldModifiers) && Modifier.isFinal(fieldModifiers))) {
            problems.add(field, "Fields must be static final.");
        }
    }
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
/**
 * Returns true if a overrides b. Assumes signatures of a and b are the same and a's declaring
 * class is a subclass of b's declaring class.
 */
private static boolean overrides(Method a, Method b) {
  // See JLS section 8.4.8.1
  int modifiers = b.getModifiers();
  if (Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers)) {
    return true;
  }
  if (Modifier.isPrivate(modifiers)) {
    return false;
  }
  // b must be package-private
  return a.getDeclaringClass().getPackage().equals(b.getDeclaringClass().getPackage());
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
private static String modifier(int mod)
{
	if( Modifier.isPublic(mod) ) return "public";
	if( Modifier.isProtected(mod) ) return "protected";
	if( Modifier.isPrivate(mod) ) return "private";
	return "";
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
private static void keepPublicConcreteClasses(final Collection<Class> classes) {
    if (null != classes) {
        final Iterator<Class> itr = classes.iterator();
        for (Class clazz = null; itr.hasNext(); clazz = itr.next()) {
            if (null != clazz) {
                final int modifiers = clazz.getModifiers();
                if (Modifier.isAbstract(modifiers) || Modifier.isInterface(modifiers) || Modifier.isPrivate(modifiers) || Modifier.isProtected(modifiers)) {
                    itr.remove();
                }
            }
        }
    }
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
private static MigratorAnalyzeResult getMigratorAnalyzeResult(Class<?> migrator) {
	MigratorAnalyzeResult migratorAnalyzeResult = 
		migratorAnalyzeResults.get(migrator.getName());
	if (migratorAnalyzeResult == null) {
		final MigratorAnalyzeResult newMigratorAnalyzeResult = 
			new MigratorAnalyzeResult();

		Method[] methods = migrator.getDeclaredMethods();
		for (int i=0; i<methods.length; i++) {
			Method method = methods[i];
			int migrateVersion = getVersion(method);
			if (migrateVersion != 0) { 
				if (Modifier.isPrivate(method.getModifiers()) && 
						!Modifier.isStatic(method.getModifiers())) {
					method.setAccessible(true);
					newMigratorAnalyzeResult.getMigrateVersions()
							.put(method.getName(), migrateVersion);
					newMigratorAnalyzeResult.getMigrateMethods().add(method);
				} else {
					throw new RuntimeException("Migrate method should be declared " +
							"as a private non-static method.");
				}
			}
		}

		Collections.sort(newMigratorAnalyzeResult.getMigrateMethods(), 
				new Comparator<Method>() {

			public int compare(Method migrate_x, Method migrate_y) {
				return newMigratorAnalyzeResult.getMigrateVersions().get(migrate_x.getName()) - 
						newMigratorAnalyzeResult.getMigrateVersions().get(migrate_y.getName());
			}
			
		});
		migratorAnalyzeResults.put(migrator.getName(), newMigratorAnalyzeResult);
		return newMigratorAnalyzeResult;
	} else {
		return migratorAnalyzeResult;
	}
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
private boolean isInstanceExtensionMethod( AbstractSrcMethod method, String extendedType )
{
  if( !Modifier.isStatic( (int)method.getModifiers() ) || Modifier.isPrivate( (int)method.getModifiers() ) )
  {
    return false;
  }

  return hasThisAnnotation( method, extendedType );
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
/**
 * Return true if the field includes the {@code private} modifier.
 */
public boolean isPrivate() {
    return Modifier.isPrivate(field.getModifiers());
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
private void validateNonRuleMethod(Method method, RuleSourceValidationProblemCollector problems) {
    if (!Modifier.isPrivate(method.getModifiers()) && !Modifier.isStatic(method.getModifiers()) && !method.isSynthetic() && !GroovyMethods.isObjectMethod(method)) {
        problems.add(method, "A method that is not annotated as a rule must be private");
    }
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
public static boolean isAllModifiersContainSpecificModifier(int allModifiers, int specificModifier) {
    if (Modifier.isAbstract(allModifiers) && Modifier.isAbstract(specificModifier))
        return true;

    if (Modifier.isFinal(allModifiers) && Modifier.isFinal(specificModifier))
        return true;

    if (Modifier.isInterface(allModifiers) && Modifier.isInterface(specificModifier))
        return true;

    if (Modifier.isNative(allModifiers) && Modifier.isNative(specificModifier))
        return true;

    if (Modifier.isPrivate(allModifiers) && Modifier.isPrivate(specificModifier))
        return true;

    if (Modifier.isProtected(allModifiers) && Modifier.isProtected(specificModifier))
        return true;

    if (Modifier.isPublic(allModifiers) && Modifier.isPublic(specificModifier))
        return true;

    if (Modifier.isStatic(allModifiers) && Modifier.isStatic(specificModifier))
        return true;

    if (Modifier.isStrict(allModifiers) && Modifier.isStrict(specificModifier))
        return true;

    if (Modifier.isSynchronized(allModifiers) && Modifier.isSynchronized(specificModifier))
        return true;

    if (Modifier.isTransient(allModifiers) && Modifier.isTransient(specificModifier))
        return true;

    if (Modifier.isVolatile(allModifiers) && Modifier.isVolatile(specificModifier))
        return true;

    if (Modifier.isVolatile(allModifiers) && Modifier.isVolatile(specificModifier))
        return true;

    return false;
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
@Override boolean isVisible(int modifiers) {
  return !Modifier.isPrivate(modifiers);
}
 

import java.lang.reflect.Modifier; //导入方法依赖的package包/类
/** Return true if the field includes the {@code private} modifier. */
public boolean isPrivate () {
	return Modifier.isPrivate(field.getModifiers());
}