Gets the super type.

@param clazz
the clazz
@return the super type
502730
private AbstractManagedType getType(Class clazz, boolean isIdClass)
    {
        if (clazz != null && !clazz.equals(Object.class))
        {
            return processInternal(clazz, isIdClass);
        }
        return null;
    }
1366422
public static Stack<Class<?>> getClassHierarchy(final Class<?> clazz) {
        final Stack<Class<?>> classHierarchy = new Stack<Class<?>>();
        Class<?> c = clazz;
        while (c != null) {
            classHierarchy.push(c);
            c = (isStatic(c.getModifiers())) ? null : c.getEnclosingClass();
        }
        return classHierarchy;
    }
191632
public static <T extends Tree> Matcher<T> isSubtypeOf(Class<?> clazz) {
    return new IsSubtypeOf<>(typeFromClass(clazz));
  }
394045
public static String type(Class<? extends ParaObject> clazz) {
		return (clazz == null) ? "" : clazz.getSimpleName().toLowerCase();
	}
1057430
public static TypeMirror getApplicationSupertype(TypeElement type) {
    TypeMirror supertype = type.getSuperclass();
    return Keys.isPlatformType(supertype.toString()) ? null : supertype;
  }
991582
public boolean isSubtypeOf(Class<?> clazz) {
		if (isType(clazz)) {
			return true;
		}
		// TODO interfaces don't inherit from non-interfaces, primitives, arrays, object
		// A final type does not have any subtypes
		JvmType type = findType(clazz);
		if (type == null) {
			return false;
		}
		return isSubtypeOf(type);
	}
445989
public static <T extends GenericEvent> GenericEventType getTypeOf(Class<T> clazz) {
    
    GenericEventType eventType = TYPE_MAP.get(clazz);
    
    if (eventType == null) {
      eventType = new GenericEventType();
      TYPE_MAP.put(clazz, eventType);
    }
    
    return eventType;
  }
580857
public static List<Class<?>> getSuperclasses(Class<?> clazz) {
        return getSuperclassesAsStream(clazz).collect(Collectors.toList());
    }
45465
public static String getResourceType(Class<? extends BoxResource> clazz) {
        BoxResourceType resource = clazz.getAnnotation(BoxResourceType.class);
        if (resource == null) {
            throw new IllegalArgumentException("Provided BoxResource type does not have @BoxResourceType annotation.");
        }
        return resource.value();
    }
288698
public static ReloadableType getRType(Class<?> clazz) {
		//		ReloadableType rtype = null;
		WeakReference<ReloadableType> ref = classToRType.get(clazz);
		ReloadableType rtype = null;
		if (ref != null) {
			rtype = ref.get();
		}
		if (rtype == null) {

			if (!theOldWay) {
				// 'theOldWay' attempts to grab the field from the type via reflection.  This usually works except
				// in cases where the class is not resolved yet since it can cause the class to resolve and its
				// static initializer to run.  This was happening on a grails compile where the compiler is
				// loading dependencies (but not initializing them).  Instead we can use this route of
				// discovering the type registry and locating the reloadable type.  This does some map lookups
				// which may be a problem, but once discovered, it is cached in the weak ref so that shouldn't
				// be an ongoing perf problem.

				// TODO testcases for something that is reloaded without having been resolved
				ClassLoader cl = clazz.getClassLoader();
				TypeRegistry tr = TypeRegistry.getTypeRegistryFor(cl);
				if (tr == null) {
					classToRType.put(clazz, ReloadableType.NOT_RELOADABLE_TYPE_REF);
				}
				else {
					rtype = tr.getReloadableType(clazz.getName().replace('.', '/'));
					if (rtype == null) {
						classToRType.put(clazz, ReloadableType.NOT_RELOADABLE_TYPE_REF);
					}
					else {
						classToRType.put(clazz, new WeakReference<ReloadableType>(rtype));
					}
				}
			}
			else {
				// need to work it out
				Field rtypeField;
				try {
					//				System.out.println("discovering field for " + clazz.getName());
					// TODO cache somewhere - will need a clazz>Field cache
					rtypeField = clazz.getDeclaredField(Constants.fReloadableTypeFieldName);
				}
				catch (NoSuchFieldException nsfe) {
					classToRType.put(clazz, ReloadableType.NOT_RELOADABLE_TYPE_REF);
					// expensive if constantly discovering this
					return null;
				}
				try {
					rtypeField.setAccessible(true);
					rtype = (ReloadableType) rtypeField.get(null);
					if (rtype == null) {
						classToRType.put(clazz, ReloadableType.NOT_RELOADABLE_TYPE_REF);
						throw new ReloadException("ReloadableType field '" + Constants.fReloadableTypeFieldName
								+ "' is 'null' on type " + clazz.getName());
					}
					else {
						classToRType.put(clazz, new WeakReference<ReloadableType>(rtype));
					}
				}
				catch (Exception e) {
					throw new ReloadException("Unable to access ReloadableType field '"
							+ Constants.fReloadableTypeFieldName
							+ "' on type " + clazz.getName(), e);
				}
			}
		}
		else if (rtype == ReloadableType.NOT_RELOADABLE_TYPE) {
			return null;
		}
		return rtype;
	}
668261
public static ClassLoader getClassLoader(Class<?> clazz) {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        if (loader != null) {
            return loader;
        }
        if (clazz != null) {
            loader = clazz.getClassLoader();
            if (loader != null) {
                return loader;
            }
        }
        return ClassLoader.getSystemClassLoader();
    }
933825
public static String getTypeStr(Class clazz) {
        String typeStr = ReflectCache.getTypeStrCache(clazz);
        if (typeStr == null) {
            if (clazz.isArray()) {
                String name = clazz.getName(); // 原始名字：[Ljava.lang.String;
                typeStr = jvmNameToCanonicalName(name); // java.lang.String[]
            } else {
                typeStr = clazz.getName();
            }
            ReflectCache.putTypeStrCache(clazz, typeStr);
        }
        return typeStr;
    }
565015
public static Set<Class<? extends Annotation>> getStereotypes(final Class<?> clazz) {
        final Set<Class<? extends Annotation>> ret = new HashSet<>();

        final Set<Annotation> annotations = getAnnotations(clazz.getAnnotations(), Stereotype.class);
        if (annotations.isEmpty()) {
            return ret;
        }

        for (final Annotation annotation : annotations) {
            ret.add(annotation.annotationType());
        }

        return ret;
    }
999115
public Class<?> getArrayType(Class<?> clazz) {

        if (clazz.isArray()) {
            return getArrayType(clazz.getComponentType());
        }

        return clazz;
    }
5937
public static boolean isGeneralArrayType(Class<?> clazz) throws NullPointerException {
        Assert.notNull(clazz, "clazz不能为null");
        String name = clazz.getName();
        return isGeneralArrayType(name);
    }
737805
public I_CmsXmlConfiguration getConfiguration(Class<?> clazz) {

        for (int i = 0; i < m_configurations.size(); i++) {
            I_CmsXmlConfiguration configuration = m_configurations.get(i);
            if (clazz.equals(configuration.getClass())) {
                return configuration;
            }
        }
        return null;
    }
9837
public static <T> Clazz<T> FindClazz( Class<T> clazz )
	{
		return impl.FindClazz( clazz );
	}