org.springframework.util

## Class ClassUtils

- java.lang.Object
- - org.springframework.util.ClassUtils

-     public abstract class ClassUtils
      extends Object

  Miscellaneous `java.lang.Class` utility methods.

  Mainly for internal use within the framework.

  Since:
    1.1
  Author:
    Juergen Hoeller, Keith Donald, Rob Harrop, Sam Brannen, Sebastien Deleuze
  See Also:
    `TypeUtils`, `ReflectionUtils`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static String` | `ARRAY_SUFFIX` Suffix for array class names: `"[]"`.
    `static String` | `CGLIB_CLASS_SEPARATOR` The CGLIB class separator: `"$$"`.
    `static String` | `CLASS_FILE_SUFFIX` The ".class" file suffix.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ClassUtils()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `static String` | `addResourcePathToPackagePath(Class<?> clazz, String resourceName)` Return a path suitable for use with `ClassLoader.getResource` (also suitable for use with `Class.getResource` by prepending a slash ('/') to the return value).
    `static String` | `classNamesToString(Class<?>... classes)` Build a String that consists of the names of the classes/interfaces in the given array.
    `static String` | `classNamesToString(Collection<Class<?>> classes)` Build a String that consists of the names of the classes/interfaces in the given collection.
    `static String` | `classPackageAsResourcePath(Class<?> clazz)` Given an input class object, return a string which consists of the class's package name as a pathname, i.e., all dots ('.') are replaced by slashes ('/').
    `static String` | `convertClassNameToResourcePath(String className)` Convert a "."-based fully qualified class name to a "/"-based resource path.
    `static String` | `convertResourcePathToClassName(String resourcePath)` Convert a "/"-based resource path to a "."-based fully qualified class name.
    `static Class<?>` | `createCompositeInterface(Class<?>[] interfaces, ClassLoader classLoader)` Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.
    `static Class<?>` | `determineCommonAncestor(Class<?> clazz1, Class<?> clazz2)` Determine the common ancestor of the given classes, if any.
    `static Class<?>` | `forName(String name, ClassLoader classLoader)` Replacement for `Class.forName()` that also returns Class instances for primitives (e.g.
    `static Class<?>[]` | `getAllInterfaces(Object instance)` Return all interfaces that the given instance implements as an array, including ones implemented by superclasses.
    `static Set<Class<?>>` | `getAllInterfacesAsSet(Object instance)` Return all interfaces that the given instance implements as a Set, including ones implemented by superclasses.
    `static Class<?>[]` | `getAllInterfacesForClass(Class<?> clazz)` Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
    `static Class<?>[]` | `getAllInterfacesForClass(Class<?> clazz, ClassLoader classLoader)` Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
    `static Set<Class<?>>` | `getAllInterfacesForClassAsSet(Class<?> clazz)` Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
    `static Set<Class<?>>` | `getAllInterfacesForClassAsSet(Class<?> clazz, ClassLoader classLoader)` Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
    `static String` | `getClassFileName(Class<?> clazz)` Determine the name of the class file, relative to the containing package: e.g.
    `static <T> Constructor<T>` | `getConstructorIfAvailable(Class<T> clazz, Class<?>... paramTypes)` Determine whether the given class has a public constructor with the given signature, and return it if available (else return `null`).
    `static ClassLoader` | `getDefaultClassLoader()` Return the default ClassLoader to use: typically the thread context ClassLoader, if available; the ClassLoader that loaded the ClassUtils class will be used as fallback.
    `static String` | `getDescriptiveType(Object value)` Return a descriptive name for the given object's type: usually simply the class name, but component type class name + "[]" for arrays, and an appended list of implemented interfaces for JDK proxies.
    `static Method` | `getInterfaceMethodIfPossible(Method method)` Deprecated. in favor of `getInterfaceMethodIfPossible(Method, Class)`
    `static Method` | `getInterfaceMethodIfPossible(Method method, Class<?> targetClass)` Determine a corresponding interface method for the given method handle, if possible.
    `static Method` | `getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)` Determine whether the given class has a public method with the given signature, and return it if available (else throws an `IllegalStateException`).
    `static int` | `getMethodCountForName(Class<?> clazz, String methodName)` Return the number of methods with a given name (with any argument types), for the given class and/or its superclasses.
    `static Method` | `getMethodIfAvailable(Class<?> clazz, String methodName, Class<?>... paramTypes)` Determine whether the given class has a public method with the given signature, and return it if available (else return `null`).
    `static Method` | `getMostSpecificMethod(Method method, Class<?> targetClass)` Given a method, which may come from an interface, and a target class used in the current reflective invocation, find the corresponding target method if there is one — for example, the method may be `IFoo.bar()`, and the target class may be `DefaultFoo`.
    `static String` | `getPackageName(Class<?> clazz)` Determine the name of the package of the given class, e.g.
    `static String` | `getPackageName(String fqClassName)` Determine the name of the package of the given fully-qualified class name, e.g.
    `static String` | `getQualifiedMethodName(Method method)` Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
    `static String` | `getQualifiedMethodName(Method method, Class<?> clazz)` Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
    `static String` | `getQualifiedName(Class<?> clazz)` Return the qualified name of the given class: usually simply the class name, but component type class name + "[]" for arrays.
    `static String` | `getShortName(Class<?> clazz)` Get the class name without the qualified package name.
    `static String` | `getShortName(String className)` Get the class name without the qualified package name.
    `static String` | `getShortNameAsProperty(Class<?> clazz)` Return the short string name of a Java class in uncapitalized JavaBeans property format.
    `static Method` | `getStaticMethod(Class<?> clazz, String methodName, Class<?>... args)` Return a public static method of a class.
    `static Class<?>` | `getUserClass(Class<?> clazz)` Return the user-defined class for the given class: usually simply the given class, but the original class in case of a CGLIB-generated subclass.
    `static Class<?>` | `getUserClass(Object instance)` Return the user-defined class for the given instance: usually simply the class of the given instance, but the original class in case of a CGLIB-generated subclass.
    `static boolean` | `hasAtLeastOneMethodWithName(Class<?> clazz, String methodName)` Does the given class or one of its superclasses at least have one or more methods with the supplied name (with any argument types)? Includes non-public methods.
    `static boolean` | `hasConstructor(Class<?> clazz, Class<?>... paramTypes)` Determine whether the given class has a public constructor with the given signature.
    `static boolean` | `hasMethod(Class<?> clazz, Method method)` Determine whether the given class has a public method with the given signature.
    `static boolean` | `hasMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)` Determine whether the given class has a public method with the given signature.
    `static boolean` | `isAssignable(Class<?> lhsType, Class<?> rhsType)` Check if the right-hand side type may be assigned to the left-hand side type, assuming setting by reflection.
    `static boolean` | `isAssignableValue(Class<?> type, Object value)` Determine if the given type is assignable from the given value, assuming setting by reflection.
    `static boolean` | `isCacheSafe(Class<?> clazz, ClassLoader classLoader)` Check whether the given class is cache-safe in the given context, i.e.
    `static boolean` | `isCglibProxy(Object object)` Deprecated. as of 5.2, in favor of custom (possibly narrower) checks such as for a Spring AOP proxy
    `static boolean` | `isCglibProxyClass(Class<?> clazz)` Deprecated. as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing `CGLIB_CLASS_SEPARATOR`
    `static boolean` | `isCglibProxyClassName(String className)` Deprecated. as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing `CGLIB_CLASS_SEPARATOR`
    `static boolean` | `isInnerClass(Class<?> clazz)` Determine if the supplied class is an inner class, i.e.
    `static boolean` | `isJavaLanguageInterface(Class<?> ifc)` Determine whether the given interface is a common Java language interface: `Serializable`, `Externalizable`, `Closeable`, `AutoCloseable`, `Cloneable`, `Comparable` - all of which can be ignored when looking for 'primary' user-level interfaces.
    `static boolean` | `isLambdaClass(Class<?> clazz)` Determine if the supplied `Class` is a JVM-generated implementation class for a lambda expression or method reference.
    `static boolean` | `isPresent(String className, ClassLoader classLoader)` Determine whether the `Class` identified by the supplied name is present and can be loaded.
    `static boolean` | `isPrimitiveArray(Class<?> clazz)` Check if the given class represents an array of primitives, i.e.
    `static boolean` | `isPrimitiveOrWrapper(Class<?> clazz)` Check if the given class represents a primitive (i.e.
    `static boolean` | `isPrimitiveWrapper(Class<?> clazz)` Check if the given class represents a primitive wrapper, i.e.
    `static boolean` | `isPrimitiveWrapperArray(Class<?> clazz)` Check if the given class represents an array of primitive wrappers, i.e.
    `static boolean` | `isUserLevelMethod(Method method)` Determine whether the given method is declared by the user or at least pointing to a user-declared method.
    `static boolean` | `isVisible(Class<?> clazz, ClassLoader classLoader)` Check whether the given class is visible in the given ClassLoader.
    `static boolean` | `matchesTypeName(Class<?> clazz, String typeName)` Check whether the given class matches the user-specified type name.
    `static ClassLoader` | `overrideThreadContextClassLoader(ClassLoader classLoaderToUse)` Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e.
    `static Class<?>` | `resolveClassName(String className, ClassLoader classLoader)` Resolve the given class name into a Class instance.
    `static Class<?>` | `resolvePrimitiveClassName(String name)` Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.
    `static Class<?>` | `resolvePrimitiveIfNecessary(Class<?> clazz)` Resolve the given class if it is a primitive class, returning the corresponding primitive wrapper type instead.
    `static Class<?>[]` | `toClassArray(Collection<Class<?>> collection)` Copy the given `Collection` into a `Class` array.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### ARRAY_SUFFIX

          public static final String ARRAY_SUFFIX

      Suffix for array class names: `"[]"`.
      See Also:
        Constant Field Values

    - #### CGLIB_CLASS_SEPARATOR

          public static final String CGLIB_CLASS_SEPARATOR

      The CGLIB class separator: `"$$"`.
      See Also:
        Constant Field Values

    - #### CLASS_FILE_SUFFIX

          public static final String CLASS_FILE_SUFFIX

      The ".class" file suffix.
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### ClassUtils

          public ClassUtils()

  - ### Method Detail

    - #### getDefaultClassLoader

          @Nullable
          public static ClassLoader getDefaultClassLoader()

      Return the default ClassLoader to use: typically the thread context ClassLoader, if available; the ClassLoader that loaded the ClassUtils class will be used as fallback.

      Call this method if you intend to use the thread context ClassLoader in a scenario where you clearly prefer a non-null ClassLoader reference: for example, for class path resource loading (but not necessarily for `Class.forName`, which accepts a `null` ClassLoader reference as well).

      Returns:
        the default ClassLoader (only `null` if even the system ClassLoader isn't accessible)
      See Also:
        `Thread.getContextClassLoader()`, `ClassLoader.getSystemClassLoader()`

    - #### overrideThreadContextClassLoader

          @Nullable
          public static ClassLoader overrideThreadContextClassLoader(@Nullable
                                                                               ClassLoader classLoaderToUse)

      Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e. if the bean ClassLoader is not equivalent to the thread context ClassLoader already.
      Parameters:
        `classLoaderToUse` - the actual ClassLoader to use for the thread context
      Returns:
        the original thread context ClassLoader, or `null` if not overridden

    - #### forName

          public static Class<?> forName(String name,
                                         @Nullable
                                         ClassLoader classLoader)
                                  throws ClassNotFoundException,
                                         LinkageError

      Replacement for `Class.forName()` that also returns Class instances for primitives (e.g. "int") and array class names (e.g. "String[]"). Furthermore, it is also capable of resolving nested class names in Java source style (e.g. "java.lang.Thread.State" instead of "java.lang.Thread$State").
      Parameters:
        `name` - the name of the Class
        `classLoader` - the class loader to use (can be `null`, which indicates the default class loader)
      Returns:
        a class instance for the supplied name
      Throws:
        `ClassNotFoundException` - if the class was not found
        `LinkageError` - if the class file could not be loaded
      See Also:
        `Class.forName(String, boolean, ClassLoader)`

    - #### resolveClassName

          public static Class<?> resolveClassName(String className,
                                                  @Nullable
                                                  ClassLoader classLoader)
                                           throws IllegalArgumentException

      Resolve the given class name into a Class instance. Supports primitives (like "int") and array class names (like "String[]").

      This is effectively equivalent to the `forName` method with the same arguments, with the only difference being the exceptions thrown in case of class loading failure.

      Parameters:
        `className` - the name of the Class
        `classLoader` - the class loader to use (can be `null`, which indicates the default class loader)
      Returns:
        a class instance for the supplied name
      Throws:
        `IllegalArgumentException` - if the class name was not resolvable (that is, the class could not be found or the class file could not be loaded)
        `IllegalStateException` - if the corresponding class is resolvable but there was a readability mismatch in the inheritance hierarchy of the class (typically a missing dependency declaration in a Jigsaw module definition for a superclass or interface implemented by the class to be loaded here)
      See Also:
        `forName(String, ClassLoader)`

    - #### isPresent

          public static boolean isPresent(String className,
                                          @Nullable
                                          ClassLoader classLoader)

      Determine whether the `Class` identified by the supplied name is present and can be loaded. Will return `false` if either the class or one of its dependencies is not present or cannot be loaded.
      Parameters:
        `className` - the name of the class to check
        `classLoader` - the class loader to use (can be `null` which indicates the default class loader)
      Returns:
        whether the specified class is present (including all of its superclasses and interfaces)
      Throws:
        `IllegalStateException` - if the corresponding class is resolvable but there was a readability mismatch in the inheritance hierarchy of the class (typically a missing dependency declaration in a Jigsaw module definition for a superclass or interface implemented by the class to be checked here)

    - #### isVisible

          public static boolean isVisible(Class<?> clazz,
                                          @Nullable
                                          ClassLoader classLoader)

      Check whether the given class is visible in the given ClassLoader.
      Parameters:
        `clazz` - the class to check (typically an interface)
        `classLoader` - the ClassLoader to check against (can be `null` in which case this method will always return `true`)

    - #### isCacheSafe

          public static boolean isCacheSafe(Class<?> clazz,
                                            @Nullable
                                            ClassLoader classLoader)

      Check whether the given class is cache-safe in the given context, i.e. whether it is loaded by the given ClassLoader or a parent of it.
      Parameters:
        `clazz` - the class to analyze
        `classLoader` - the ClassLoader to potentially cache metadata in (can be `null` which indicates the system class loader)

    - #### resolvePrimitiveClassName

          @Nullable
          public static Class<?> resolvePrimitiveClassName(@Nullable
                                                                     String name)

      Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.

      Also supports the JVM's internal class names for primitive arrays. Does not support the "[]" suffix notation for primitive arrays; this is only supported by `forName(String, ClassLoader)`.

      Parameters:
        `name` - the name of the potentially primitive class
      Returns:
        the primitive class, or `null` if the name does not denote a primitive class or primitive array class

    - #### isPrimitiveWrapper

          public static boolean isPrimitiveWrapper(Class<?> clazz)

      Check if the given class represents a primitive wrapper, i.e. Boolean, Byte, Character, Short, Integer, Long, Float, Double, or Void.
      Parameters:
        `clazz` - the class to check
      Returns:
        whether the given class is a primitive wrapper class

    - #### isPrimitiveOrWrapper

          public static boolean isPrimitiveOrWrapper(Class<?> clazz)

      Check if the given class represents a primitive (i.e. boolean, byte, char, short, int, long, float, or double), `void`, or a wrapper for those types (i.e. Boolean, Byte, Character, Short, Integer, Long, Float, Double, or Void).
      Parameters:
        `clazz` - the class to check
      Returns:
        `true` if the given class represents a primitive, void, or a wrapper class

    - #### isPrimitiveArray

          public static boolean isPrimitiveArray(Class<?> clazz)

      Check if the given class represents an array of primitives, i.e. boolean, byte, char, short, int, long, float, or double.
      Parameters:
        `clazz` - the class to check
      Returns:
        whether the given class is a primitive array class

    - #### isPrimitiveWrapperArray

          public static boolean isPrimitiveWrapperArray(Class<?> clazz)

      Check if the given class represents an array of primitive wrappers, i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.
      Parameters:
        `clazz` - the class to check
      Returns:
        whether the given class is a primitive wrapper array class

    - #### resolvePrimitiveIfNecessary

          public static Class<?> resolvePrimitiveIfNecessary(Class<?> clazz)

      Resolve the given class if it is a primitive class, returning the corresponding primitive wrapper type instead.
      Parameters:
        `clazz` - the class to check
      Returns:
        the original class, or a primitive wrapper for the original primitive type

    - #### isAssignable

          public static boolean isAssignable(Class<?> lhsType,
                                             Class<?> rhsType)

      Check if the right-hand side type may be assigned to the left-hand side type, assuming setting by reflection. Considers primitive wrapper classes as assignable to the corresponding primitive types.
      Parameters:
        `lhsType` - the target type (left-hand side (LHS) type)
        `rhsType` - the value type (right-hand side (RHS) type) that should be assigned to the target type
      Returns:
        `true` if `rhsType` is assignable to `lhsType`
      See Also:
        `TypeUtils.isAssignable(java.lang.reflect.Type, java.lang.reflect.Type)`

    - #### isAssignableValue

          public static boolean isAssignableValue(Class<?> type,
                                                  @Nullable
                                                  Object value)

      Determine if the given type is assignable from the given value, assuming setting by reflection. Considers primitive wrapper classes as assignable to the corresponding primitive types.
      Parameters:
        `type` - the target type
        `value` - the value that should be assigned to the type
      Returns:
        if the type is assignable from the value

    - #### convertResourcePathToClassName

          public static String convertResourcePathToClassName(String resourcePath)

      Convert a "/"-based resource path to a "."-based fully qualified class name.
      Parameters:
        `resourcePath` - the resource path pointing to a class
      Returns:
        the corresponding fully qualified class name

    - #### convertClassNameToResourcePath

          public static String convertClassNameToResourcePath(String className)

      Convert a "."-based fully qualified class name to a "/"-based resource path.
      Parameters:
        `className` - the fully qualified class name
      Returns:
        the corresponding resource path, pointing to the class

    - #### addResourcePathToPackagePath

          public static String addResourcePathToPackagePath(Class<?> clazz,
                                                            String resourceName)

      Return a path suitable for use with `ClassLoader.getResource` (also suitable for use with `Class.getResource` by prepending a slash ('/') to the return value). Built by taking the package of the specified class file, converting all dots ('.') to slashes ('/'), adding a trailing slash if necessary, and concatenating the specified resource name to this.
      As such, this function may be used to build a path suitable for loading a resource file that is in the same package as a class file, although `ClassPathResource` is usually even more convenient.
      Parameters:
        `clazz` - the Class whose package will be used as the base
        `resourceName` - the resource name to append. A leading slash is optional.
      Returns:
        the built-up resource path
      See Also:
        `ClassLoader.getResource(java.lang.String)`, `Class.getResource(java.lang.String)`

    - #### classPackageAsResourcePath

          public static String classPackageAsResourcePath(@Nullable
                                                          Class<?> clazz)

      Given an input class object, return a string which consists of the class's package name as a pathname, i.e., all dots ('.') are replaced by slashes ('/'). Neither a leading nor trailing slash is added. The result could be concatenated with a slash and the name of a resource and fed directly to `ClassLoader.getResource()`. For it to be fed to `Class.getResource` instead, a leading slash would also have to be prepended to the returned value.
      Parameters:
        `clazz` - the input class. A `null` value or the default (empty) package will result in an empty string ("") being returned.
      Returns:
        a path which represents the package name
      See Also:
        `ClassLoader.getResource(java.lang.String)`, `Class.getResource(java.lang.String)`

    - #### classNamesToString

          public static String classNamesToString(Class<?>... classes)

      Build a String that consists of the names of the classes/interfaces in the given array.

      Basically like `AbstractCollection.toString()`, but stripping the "class "/"interface " prefix before every class name.

      Parameters:
        `classes` - an array of Class objects
      Returns:
        a String of form "[com.foo.Bar, com.foo.Baz]"
      See Also:
        `AbstractCollection.toString()`

    - #### classNamesToString

          public static String classNamesToString(@Nullable
                                                  Collection<Class<?>> classes)

      Build a String that consists of the names of the classes/interfaces in the given collection.

      Basically like `AbstractCollection.toString()`, but stripping the "class "/"interface " prefix before every class name.

      Parameters:
        `classes` - a Collection of Class objects (can be `null`)
      Returns:
        a String of form "[com.foo.Bar, com.foo.Baz]"
      See Also:
        `AbstractCollection.toString()`

    - #### toClassArray

          public static Class<?>[] toClassArray(@Nullable
                                                Collection<Class<?>> collection)

      Copy the given `Collection` into a `Class` array.

      The `Collection` must contain `Class` elements only.

      Parameters:
        `collection` - the `Collection` to copy
      Returns:
        the `Class` array
      Since:
        3.1
      See Also:
        `StringUtils.toStringArray(java.util.Collection<java.lang.String>)`

    - #### getAllInterfaces

          public static Class<?>[] getAllInterfaces(Object instance)

      Return all interfaces that the given instance implements as an array, including ones implemented by superclasses.
      Parameters:
        `instance` - the instance to analyze for interfaces
      Returns:
        all interfaces that the given instance implements as an array

    - #### getAllInterfacesForClass

          public static Class<?>[] getAllInterfacesForClass(Class<?> clazz)

      Return all interfaces that the given class implements as an array, including ones implemented by superclasses.

      If the class itself is an interface, it gets returned as sole interface.

      Parameters:
        `clazz` - the class to analyze for interfaces
      Returns:
        all interfaces that the given object implements as an array

    - #### getAllInterfacesForClass

          public static Class<?>[] getAllInterfacesForClass(Class<?> clazz,
                                                            @Nullable
                                                            ClassLoader classLoader)

      Return all interfaces that the given class implements as an array, including ones implemented by superclasses.

      If the class itself is an interface, it gets returned as sole interface.

      Parameters:
        `clazz` - the class to analyze for interfaces
        `classLoader` - the ClassLoader that the interfaces need to be visible in (can be `null` when accepting all declared interfaces)
      Returns:
        all interfaces that the given object implements as an array

    - #### getAllInterfacesAsSet

          public static Set<Class<?>> getAllInterfacesAsSet(Object instance)

      Return all interfaces that the given instance implements as a Set, including ones implemented by superclasses.
      Parameters:
        `instance` - the instance to analyze for interfaces
      Returns:
        all interfaces that the given instance implements as a Set

    - #### getAllInterfacesForClassAsSet

          public static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz)

      Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.

      If the class itself is an interface, it gets returned as sole interface.

      Parameters:
        `clazz` - the class to analyze for interfaces
      Returns:
        all interfaces that the given object implements as a Set

    - #### getAllInterfacesForClassAsSet

          public static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz,
                                                                    @Nullable
                                                                    ClassLoader classLoader)

      Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.

      If the class itself is an interface, it gets returned as sole interface.

      Parameters:
        `clazz` - the class to analyze for interfaces
        `classLoader` - the ClassLoader that the interfaces need to be visible in (can be `null` when accepting all declared interfaces)
      Returns:
        all interfaces that the given object implements as a Set

    - #### createCompositeInterface

          public static Class<?> createCompositeInterface(Class<?>[] interfaces,
                                                          @Nullable
                                                          ClassLoader classLoader)

      Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.

      This implementation builds a JDK proxy class for the given interfaces.

      Parameters:
        `interfaces` - the interfaces to merge
        `classLoader` - the ClassLoader to create the composite Class in
      Returns:
        the merged interface as Class
      Throws:
        `IllegalArgumentException` - if the specified interfaces expose conflicting method signatures (or a similar constraint is violated)
      See Also:
        `Proxy.getProxyClass(java.lang.ClassLoader, java.lang.Class<?>...)`

    - #### determineCommonAncestor

          @Nullable
          public static Class<?> determineCommonAncestor(@Nullable
                                                                   Class<?> clazz1,
                                                                   @Nullable
                                                                   Class<?> clazz2)

      Determine the common ancestor of the given classes, if any.
      Parameters:
        `clazz1` - the class to introspect
        `clazz2` - the other class to introspect
      Returns:
        the common ancestor (i.e. common superclass, one interface extending the other), or `null` if none found. If any of the given classes is `null`, the other class will be returned.
      Since:
        3.2.6

    - #### isJavaLanguageInterface

          public static boolean isJavaLanguageInterface(Class<?> ifc)

      Determine whether the given interface is a common Java language interface: `Serializable`, `Externalizable`, `Closeable`, `AutoCloseable`, `Cloneable`, `Comparable` - all of which can be ignored when looking for 'primary' user-level interfaces. Common characteristics: no service-level operations, no bean property methods, no default methods.
      Parameters:
        `ifc` - the interface to check
      Since:
        5.0.3

    - #### isInnerClass

          public static boolean isInnerClass(Class<?> clazz)

      Determine if the supplied class is an inner class, i.e. a non-static member of an enclosing class.
      Returns:
        `true` if the supplied class is an inner class
      Since:
        5.0.5
      See Also:
        `Class.isMemberClass()`

    - #### isLambdaClass

          public static boolean isLambdaClass(Class<?> clazz)

      Determine if the supplied `Class` is a JVM-generated implementation class for a lambda expression or method reference.

      This method makes a best-effort attempt at determining this, based on checks that work on modern, mainstream JVMs.

      Parameters:
        `clazz` - the class to check
      Returns:
        `true` if the class is a lambda implementation class
      Since:
        5.3.19

    - #### isCglibProxy

          @Deprecated
          public static boolean isCglibProxy(Object object)

      Deprecated. as of 5.2, in favor of custom (possibly narrower) checks such as for a Spring AOP proxy
      Check whether the given object is a CGLIB proxy.
      Parameters:
        `object` - the object to check
      See Also:
        `AopUtils.isCglibProxy(Object)`

    - #### isCglibProxyClass

          @Deprecated
          public static boolean isCglibProxyClass(@Nullable
                                                              Class<?> clazz)

      Deprecated. as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing `CGLIB_CLASS_SEPARATOR`
      Check whether the specified class is a CGLIB-generated class.
      Parameters:
        `clazz` - the class to check
      See Also:
        `getUserClass(Class)`

    - #### isCglibProxyClassName

          @Deprecated
          public static boolean isCglibProxyClassName(@Nullable
                                                                  String className)

      Deprecated. as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing `CGLIB_CLASS_SEPARATOR`
      Check whether the specified class name is a CGLIB-generated class.
      Parameters:
        `className` - the class name to check
      See Also:
        `CGLIB_CLASS_SEPARATOR`

    - #### getUserClass

          public static Class<?> getUserClass(Object instance)

      Return the user-defined class for the given instance: usually simply the class of the given instance, but the original class in case of a CGLIB-generated subclass.
      Parameters:
        `instance` - the instance to check
      Returns:
        the user-defined class

    - #### getUserClass

          public static Class<?> getUserClass(Class<?> clazz)

      Return the user-defined class for the given class: usually simply the given class, but the original class in case of a CGLIB-generated subclass.
      Parameters:
        `clazz` - the class to check
      Returns:
        the user-defined class
      See Also:
        `CGLIB_CLASS_SEPARATOR`

    - #### getDescriptiveType

          @Nullable
          public static String getDescriptiveType(@Nullable
                                                            Object value)

      Return a descriptive name for the given object's type: usually simply the class name, but component type class name + "[]" for arrays, and an appended list of implemented interfaces for JDK proxies.
      Parameters:
        `value` - the value to introspect
      Returns:
        the qualified name of the class

    - #### matchesTypeName

          public static boolean matchesTypeName(Class<?> clazz,
                                                @Nullable
                                                String typeName)

      Check whether the given class matches the user-specified type name.
      Parameters:
        `clazz` - the class to check
        `typeName` - the type name to match

    - #### getShortName

          public static String getShortName(String className)

      Get the class name without the qualified package name.
      Parameters:
        `className` - the className to get the short name for
      Returns:
        the class name of the class without the package name
      Throws:
        `IllegalArgumentException` - if the className is empty

    - #### getShortName

          public static String getShortName(Class<?> clazz)

      Get the class name without the qualified package name.
      Parameters:
        `clazz` - the class to get the short name for
      Returns:
        the class name of the class without the package name

    - #### getShortNameAsProperty

          public static String getShortNameAsProperty(Class<?> clazz)

      Return the short string name of a Java class in uncapitalized JavaBeans property format. Strips the outer class name in case of a nested class.
      Parameters:
        `clazz` - the class
      Returns:
        the short name rendered in a standard JavaBeans property format
      See Also:
        `Introspector.decapitalize(String)`

    - #### getClassFileName

          public static String getClassFileName(Class<?> clazz)

      Determine the name of the class file, relative to the containing package: e.g. "String.class"
      Parameters:
        `clazz` - the class
      Returns:
        the file name of the ".class" file

    - #### getPackageName

          public static String getPackageName(Class<?> clazz)

      Determine the name of the package of the given class, e.g. "java.lang" for the `java.lang.String` class.
      Parameters:
        `clazz` - the class
      Returns:
        the package name, or the empty String if the class is defined in the default package

    - #### getPackageName

          public static String getPackageName(String fqClassName)

      Determine the name of the package of the given fully-qualified class name, e.g. "java.lang" for the `java.lang.String` class name.
      Parameters:
        `fqClassName` - the fully-qualified class name
      Returns:
        the package name, or the empty String if the class is defined in the default package

    - #### getQualifiedName

          public static String getQualifiedName(Class<?> clazz)

      Return the qualified name of the given class: usually simply the class name, but component type class name + "[]" for arrays.
      Parameters:
        `clazz` - the class
      Returns:
        the qualified name of the class

    - #### getQualifiedMethodName

          public static String getQualifiedMethodName(Method method)

      Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
      Parameters:
        `method` - the method
      Returns:
        the qualified name of the method

    - #### getQualifiedMethodName

          public static String getQualifiedMethodName(Method method,
                                                      @Nullable
                                                      Class<?> clazz)

      Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
      Parameters:
        `method` - the method
        `clazz` - the clazz that the method is being invoked on (can be `null` to indicate the method's declaring class)
      Returns:
        the qualified name of the method
      Since:
        4.3.4

    - #### hasConstructor

          public static boolean hasConstructor(Class<?> clazz,
                                               Class<?>... paramTypes)

      Determine whether the given class has a public constructor with the given signature.

      Essentially translates `NoSuchMethodException` to "false".

      Parameters:
        `clazz` - the clazz to analyze
        `paramTypes` - the parameter types of the method
      Returns:
        whether the class has a corresponding constructor
      See Also:
        `Class.getConstructor(java.lang.Class<?>...)`

    - #### getConstructorIfAvailable

          @Nullable
          public static <T> Constructor<T> getConstructorIfAvailable(Class<T> clazz,
                                                                               Class<?>... paramTypes)

      Determine whether the given class has a public constructor with the given signature, and return it if available (else return `null`).

      Essentially translates `NoSuchMethodException` to `null`.

      Parameters:
        `clazz` - the clazz to analyze
        `paramTypes` - the parameter types of the method
      Returns:
        the constructor, or `null` if not found
      See Also:
        `Class.getConstructor(java.lang.Class<?>...)`

    - #### hasMethod

          public static boolean hasMethod(Class<?> clazz,
                                          Method method)

      Determine whether the given class has a public method with the given signature.
      Parameters:
        `clazz` - the clazz to analyze
        `method` - the method to look for
      Returns:
        whether the class has a corresponding method
      Since:
        5.2.3

    - #### hasMethod

          public static boolean hasMethod(Class<?> clazz,
                                          String methodName,
                                          Class<?>... paramTypes)

      Determine whether the given class has a public method with the given signature.

      Essentially translates `NoSuchMethodException` to "false".

      Parameters:
        `clazz` - the clazz to analyze
        `methodName` - the name of the method
        `paramTypes` - the parameter types of the method
      Returns:
        whether the class has a corresponding method
      See Also:
        `Class.getMethod(java.lang.String, java.lang.Class<?>...)`

    - #### getMethod

          public static Method getMethod(Class<?> clazz,
                                         String methodName,
                                         @Nullable
                                         Class<?>... paramTypes)

      Determine whether the given class has a public method with the given signature, and return it if available (else throws an `IllegalStateException`).

      In case of any signature specified, only returns the method if there is a unique candidate, i.e. a single public method with the specified name.

      Essentially translates `NoSuchMethodException` to `IllegalStateException`.

      Parameters:
        `clazz` - the clazz to analyze
        `methodName` - the name of the method
        `paramTypes` - the parameter types of the method (can be `null` to indicate any signature)
      Returns:
        the method (never `null`)
      Throws:
        `IllegalStateException` - if the method has not been found
      See Also:
        `Class.getMethod(java.lang.String, java.lang.Class<?>...)`

    - #### getMethodIfAvailable

          @Nullable
          public static Method getMethodIfAvailable(Class<?> clazz,
                                                              String methodName,
                                                              @Nullable
                                                              Class<?>... paramTypes)

      Determine whether the given class has a public method with the given signature, and return it if available (else return `null`).

      In case of any signature specified, only returns the method if there is a unique candidate, i.e. a single public method with the specified name.

      Essentially translates `NoSuchMethodException` to `null`.

      Parameters:
        `clazz` - the clazz to analyze
        `methodName` - the name of the method
        `paramTypes` - the parameter types of the method (can be `null` to indicate any signature)
      Returns:
        the method, or `null` if not found
      See Also:
        `Class.getMethod(java.lang.String, java.lang.Class<?>...)`

    - #### getMethodCountForName

          public static int getMethodCountForName(Class<?> clazz,
                                                  String methodName)

      Return the number of methods with a given name (with any argument types), for the given class and/or its superclasses. Includes non-public methods.
      Parameters:
        `clazz` - the clazz to check
        `methodName` - the name of the method
      Returns:
        the number of methods with the given name

    - #### hasAtLeastOneMethodWithName

          public static boolean hasAtLeastOneMethodWithName(Class<?> clazz,
                                                            String methodName)

      Does the given class or one of its superclasses at least have one or more methods with the supplied name (with any argument types)? Includes non-public methods.
      Parameters:
        `clazz` - the clazz to check
        `methodName` - the name of the method
      Returns:
        whether there is at least one method with the given name

    - #### getMostSpecificMethod

          public static Method getMostSpecificMethod(Method method,
                                                     @Nullable
                                                     Class<?> targetClass)

      Given a method, which may come from an interface, and a target class used in the current reflective invocation, find the corresponding target method if there is one — for example, the method may be `IFoo.bar()`, and the target class may be `DefaultFoo`. In this case, the method may be `DefaultFoo.bar()`. This enables attributes on that method to be found.

      NOTE: In contrast to `AopUtils.getMostSpecificMethod(java.lang.reflect.Method, java.lang.Class<?>)`, this method does not resolve bridge methods automatically. Call `BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method)` if bridge method resolution is desirable — for example, to obtain metadata from the original method definition.

      NOTE: If Java security settings disallow reflective access — for example, calls to `Class#getDeclaredMethods`, etc. — this implementation will fall back to returning the originally provided method.

      Parameters:
        `method` - the method to be invoked, which may come from an interface
        `targetClass` - the target class for the current invocation (can be `null` or may not even implement the method)
      Returns:
        the specific target method, or the original method if the `targetClass` does not implement it
      See Also:
        `getInterfaceMethodIfPossible(Method, Class)`

    - #### getInterfaceMethodIfPossible

          @Deprecated
          public static Method getInterfaceMethodIfPossible(Method method)

      Deprecated. in favor of `getInterfaceMethodIfPossible(Method, Class)`
      Determine a corresponding interface method for the given method handle, if possible.

      This is particularly useful for arriving at a public exported type on Jigsaw which can be reflectively invoked without an illegal access warning.

      Parameters:
        `method` - the method to be invoked, potentially from an implementation class
      Returns:
        the corresponding interface method, or the original method if none found
      Since:
        5.1

    - #### getInterfaceMethodIfPossible

          public static Method getInterfaceMethodIfPossible(Method method,
                                                            @Nullable
                                                            Class<?> targetClass)

      Determine a corresponding interface method for the given method handle, if possible.

      This is particularly useful for arriving at a public exported type on Jigsaw which can be reflectively invoked without an illegal access warning.

      Parameters:
        `method` - the method to be invoked, potentially from an implementation class
        `targetClass` - the target class to check for declared interfaces
      Returns:
        the corresponding interface method, or the original method if none found
      Since:
        5.3.16
      See Also:
        `getMostSpecificMethod(java.lang.reflect.Method, java.lang.Class<?>)`

    - #### isUserLevelMethod

          public static boolean isUserLevelMethod(Method method)

      Determine whether the given method is declared by the user or at least pointing to a user-declared method.

      Checks `Method.isSynthetic()` (for implementation methods) as well as the `GroovyObject` interface (for interface methods; on an implementation class, implementations of the `GroovyObject` methods will be marked as synthetic anyway). Note that, despite being synthetic, bridge methods (`Method.isBridge()`) are considered as user-level methods since they are eventually pointing to a user-declared generic method.

      Parameters:
        `method` - the method to check
      Returns:
        `true` if the method can be considered as user-declared; `false` otherwise

    - #### getStaticMethod

          @Nullable
          public static Method getStaticMethod(Class<?> clazz,
                                                         String methodName,
                                                         Class<?>... args)

      Return a public static method of a class.
      Parameters:
        `clazz` - the class which defines the method
        `methodName` - the static method name
        `args` - the parameter types to the method
      Returns:
        the static method, or `null` if no static method was found
      Throws:
        `IllegalArgumentException` - if the method name is blank or the clazz is null