Java Utililty Methods Reflection Interface Get

List<Class<?>> implemented = new ArrayList<Class<?>>();
getAllInterfaces(clazz, implemented);
return implemented;

List<Class<?>> allInterfaces = new ArrayList<>();
Class<?> superClass = clazz;
while (superClass != null) {
    Class<?>[] interfaces = superClass.getInterfaces();
    if (interfaces != null && interfaces.length > 0) {
        for (int index = 0; index < interfaces.length; index++) {
            allInterfaces.add(interfaces[index]);
    superClass = superClass.getSuperclass();
return allInterfaces.toArray(new Class<?>[allInterfaces.size()]);

if (cls == null) {
    return null;
List<Class<?>> list = new ArrayList<Class<?>>();
while (cls != null) {
    Class[] interfaces = cls.getInterfaces();
    for (int i = 0; i < interfaces.length; i++) {
        if (!list.contains(interfaces[i])) {
...

if (cls == null) {
    return null;
final List<Class<?>> list = new ArrayList<Class<?>>();
while (cls != null) {
    final Class<?>[] interfaces = cls.getInterfaces();
    for (final Class<?> interface1 : interfaces) {
        if (list.contains(interface1) == false) {
...

List<Class<?>> allInterfaces = new ArrayList<Class<?>>();
if (!type.isInterface()) {
    Class<?> superclass = type.getSuperclass();
    if (superclass != null) {
        List<Class<?>> superIfs = getAllInterfaces(superclass);
        for (Class<?> superIf : superIfs) {
            if (!allInterfaces.contains(superIf)) {
                allInterfaces.add(superIf);
...

List interfaces = getAllInterfacesAsList(object);
return (Class[]) interfaces.toArray(new Class[interfaces.size()]);

while (clazz != null) {
    searchInterfaces.addAll(Arrays.asList(clazz.getInterfaces()));
    for (Class<?> intf : clazz.getInterfaces()) {
        getAllInterfaces(searchInterfaces, intf);
    clazz = clazz.getSuperclass();

return getAllInterfacesForClass(clazz, null);

return toString(getAllInterfaces(aClass));

List<Class<?>> classes = new ArrayList<Class<?>>();
while (c != Object.class) {
    classes.add(c);
    if (includeInterfaces) {
        Class<?>[] interfaces = c.getInterfaces();
        for (Class<?> i : interfaces) {
            classes.add(i);
    c = c.getSuperclass();
    if (c == null) {
        break;
return classes;