How to use

getGenericInterfaces

method

in

java.lang.Class

/**
 * @since 2.7
 */
public static Type[] getGenericInterfaces(Class<?> cls) {
  return cls.getGenericInterfaces();
}

/**
 * @since 2.7
 */
public static Type[] getGenericInterfaces(Class<?> cls) {
  return cls.getGenericInterfaces();
}

public static Class<?> getGenericClass(Class<?> cls, int i) {
  try {
    ParameterizedType parameterizedType = ((ParameterizedType) cls.getGenericInterfaces()[0]);
    Object genericClass = parameterizedType.getActualTypeArguments()[i];
    if (genericClass instanceof ParameterizedType) { // handle nested generic type
      return (Class<?>) ((ParameterizedType) genericClass).getRawType();
    } else if (genericClass instanceof GenericArrayType) { // handle array generic type
      return (Class<?>) ((GenericArrayType) genericClass).getGenericComponentType();
    } else if (((Class) genericClass).isArray()) {
      // Requires JDK 7 or higher, Foo<int[]> is no longer GenericArrayType
      return ((Class) genericClass).getComponentType();
    } else {
      return (Class<?>) genericClass;
    }
  } catch (Throwable e) {
    throw new IllegalArgumentException(cls.getName()
        + " generic type undefined!", e);
  }
}

public static Class<?> getGenericClass(Class<?> cls, int i) {
  try {
    ParameterizedType parameterizedType = ((ParameterizedType) cls.getGenericInterfaces()[0]);
    Object genericClass = parameterizedType.getActualTypeArguments()[i];
    if (genericClass instanceof ParameterizedType) { // handle nested generic type
      return (Class<?>) ((ParameterizedType) genericClass).getRawType();
    } else if (genericClass instanceof GenericArrayType) { // handle array generic type
      return (Class<?>) ((GenericArrayType) genericClass).getGenericComponentType();
    } else if (((Class) genericClass).isArray()) {
      // Requires JDK 7 or higher, Foo<int[]> is no longer GenericArrayType
      return ((Class) genericClass).getComponentType();
    } else {
      return (Class<?>) genericClass;
    }
  } catch (Throwable e) {
    throw new IllegalArgumentException(cls.getName()
        + " generic type undefined!", e);
  }
}

@Override
void visitClass(Class<?> clazz) {
 visit(clazz.getGenericSuperclass());
 visit(clazz.getGenericInterfaces());
}

/**
 * Finds generic interface implementation based on the source class and the target interface.
 * Returns null if not found. Recurses the interface hierarchy.
 */
private static Type findGenericInterface(Class<?> sourceClass, Class<?> targetBaseInterface) {
  for (int i = 0; i < sourceClass.getInterfaces().length; i++) {
    Class<?> inter = sourceClass.getInterfaces()[i];
    if (inter == targetBaseInterface) {
      return sourceClass.getGenericInterfaces()[0];
    } else {
      Type deeper = findGenericInterface(inter, targetBaseInterface);
      if (deeper != null) {
        return deeper;
      }
    }
  }
  return null;
}

public static Class<?> getGenericClass(Class<?> cls, int i) {
  try {
    ParameterizedType parameterizedType = ((ParameterizedType) cls.getGenericInterfaces()[0]);
    Object genericClass = parameterizedType.getActualTypeArguments()[i];
    if (genericClass instanceof ParameterizedType) {
      return (Class<?>) ((ParameterizedType) genericClass).getRawType();
    } else if (genericClass instanceof GenericArrayType) {
      Type type = ((GenericArrayType) genericClass).getGenericComponentType();
      if (type instanceof TypeVariable) {
        return type.getClass();
      }
      return (((GenericArrayType) genericClass).getGenericComponentType() instanceof Class<?>)
          ? (Class<?>) ((GenericArrayType) genericClass).getGenericComponentType()
          : ((GenericArrayType) genericClass).getGenericComponentType().getClass();
    } else if (genericClass != null) {
      if (genericClass instanceof TypeVariable) {
        return genericClass.getClass();
      }
      return (Class<?>) genericClass;
    }
  } catch (Throwable e) {
  }
  if (cls.getSuperclass() != null) {
    return getGenericClass(cls.getSuperclass(), i);
  } else {
    throw new IllegalArgumentException(cls.getName() + " generic type undefined!");
  }
}

public static Class<?> getGenericClass(Class<?> cls, int i) {
  try {
    ParameterizedType parameterizedType = ((ParameterizedType) cls.getGenericInterfaces()[0]);
    Object genericClass = parameterizedType.getActualTypeArguments()[i];
    if (genericClass instanceof ParameterizedType) {
      return (Class<?>) ((ParameterizedType) genericClass).getRawType();
    } else if (genericClass instanceof GenericArrayType) {
      Type type = ((GenericArrayType) genericClass).getGenericComponentType();
      if (type instanceof TypeVariable) {
        return type.getClass();
      }
      return (((GenericArrayType) genericClass).getGenericComponentType() instanceof Class<?>)
          ? (Class<?>) ((GenericArrayType) genericClass).getGenericComponentType()
          : ((GenericArrayType) genericClass).getGenericComponentType().getClass();
    } else if (genericClass != null) {
      if (genericClass instanceof TypeVariable) {
        return genericClass.getClass();
      }
      return (Class<?>) genericClass;
    }
  } catch (Throwable e) {
  }
  if (cls.getSuperclass() != null) {
    return getGenericClass(cls.getSuperclass(), i);
  } else {
    throw new IllegalArgumentException(cls.getName() + " generic type undefined!");
  }
}

for (int i = 0, length = interfaces.length; i < length; i++) {
 if (interfaces[i] == toResolve) {
  return rawType.getGenericInterfaces()[i];
 } else if (toResolve.isAssignableFrom(interfaces[i])) {
  return getGenericSupertype(rawType.getGenericInterfaces()[i], interfaces[i], toResolve);

/**
 * Registers the type variables for the given type and all of its superclasses and superinterfaces.
 */
protected void registerAllTypeVariables(Type classType) {
  Queue<Type> typesToRegister = new LinkedList<Type>();
  Set<Type> registeredTypes = new HashSet<Type>();
  typesToRegister.add(classType);
  while (!typesToRegister.isEmpty()) {
    Type typeToRegister = typesToRegister.poll();
    if (typeToRegister == null || registeredTypes.contains(typeToRegister)) {
      continue;
    }
    registerTypeVariablesOn(typeToRegister);
    registeredTypes.add(typeToRegister);
    Class<?> rawType = extractRawTypeOf(typeToRegister);
    typesToRegister.add(rawType.getGenericSuperclass());
    typesToRegister.addAll(Arrays.asList(rawType.getGenericInterfaces()));
  }
}

@Override
void visitClass(Class<?> clazz) {
 visit(clazz.getGenericSuperclass());
 visit(clazz.getGenericInterfaces());
}

/**
 * Returns the generic interfaces that this type directly {@code implements}. This method is
 * similar but different from {@link Class#getGenericInterfaces()}. For example, {@code new
 * TypeToken<List<String>>() {}.getGenericInterfaces()} will return a list that contains {@code
 * new TypeToken<Iterable<String>>() {}}; while {@code List.class.getGenericInterfaces()} will
 * return an array that contains {@code Iterable<T>}, where the {@code T} is the type variable
 * declared by interface {@code Iterable}.
 *
 * <p>If this type is a type variable or wildcard, its upper bounds are examined and those that
 * are either an interface or upper-bounded only by interfaces are returned. This means that the
 * returned types could include type variables too.
 */
final ImmutableList<TypeToken<? super T>> getGenericInterfaces() {
 if (runtimeType instanceof TypeVariable) {
  return boundsAsInterfaces(((TypeVariable<?>) runtimeType).getBounds());
 }
 if (runtimeType instanceof WildcardType) {
  return boundsAsInterfaces(((WildcardType) runtimeType).getUpperBounds());
 }
 ImmutableList.Builder<TypeToken<? super T>> builder = ImmutableList.builder();
 for (Type interfaceType : getRawType().getGenericInterfaces()) {
  @SuppressWarnings("unchecked") // interface of T
  TypeToken<? super T> resolvedInterface =
    (TypeToken<? super T>) resolveSupertype(interfaceType);
  builder.add(resolvedInterface);
 }
 return builder.build();
}

@Override
void visitClass(Class<?> clazz) {
 visit(clazz.getGenericSuperclass());
 visit(clazz.getGenericInterfaces());
}

/**
 * Return a {@link ResolvableType} array representing the direct interfaces
 * implemented by this type. If this type does not implement any interfaces an
 * empty array is returned.
 * <p>Note: The resulting {@link ResolvableType} instances may not be {@link Serializable}.
 * @see #getSuperType()
 */
public ResolvableType[] getInterfaces() {
  Class<?> resolved = resolve();
  if (resolved == null) {
    return EMPTY_TYPES_ARRAY;
  }
  ResolvableType[] interfaces = this.interfaces;
  if (interfaces == null) {
    Type[] genericIfcs = resolved.getGenericInterfaces();
    interfaces = new ResolvableType[genericIfcs.length];
    for (int i = 0; i < genericIfcs.length; i++) {
      interfaces[i] = forType(genericIfcs[i], this);
    }
    this.interfaces = interfaces;
  }
  return interfaces;
}

public void testGetType() {
 TypeToken<?> t = TypeToken.of(StringList.class.getGenericInterfaces()[0]);
 assertEquals(new TypeToken<List<String>>() {}, t);
}

public void testTypeIsCorrect() {
 TypeToken<List<String>> token = new TypeToken<List<String>>() {};
 assertEquals(StringList.class.getGenericInterfaces()[0], token.getType());
}

@Override
@CachedReturnPlugin.Enhance("resolved")
protected TypeDescription.Generic resolve() {
  java.lang.reflect.Type[] type = this.type.getGenericInterfaces();
  return erasure.length == type.length
      ? Sort.describe(type[index], getAnnotationReader())
      : asRawType();
}

public void testAssignableParameterizedTypeToType() {
 TypeToken<List<String>> tokenL = new TypeToken<List<String>>() {};
 assertTrue(tokenL.isSupertypeOf(StringList.class.getGenericInterfaces()[0]));
 assertFalse(tokenL.isSupertypeOf(IntegerList.class.getGenericInterfaces()[0]));
 TypeToken<First<String>> tokenF = new TypeToken<First<String>>() {};
 assertTrue(tokenF.isSupertypeOf(ConcreteIS.class.getGenericSuperclass()));
 assertFalse(tokenF.isSupertypeOf(ConcreteSI.class.getGenericSuperclass()));
}

public void testAssignableParameterizedTypeToClass() {
 @SuppressWarnings("rawtypes") // Trying to test raw class
 TypeToken<List> tokL = new TypeToken<List>() {};
 assertTrue(tokL.isSupertypeOf(StringList.class));
 assertTrue(tokL.isSupertypeOf(StringList.class.getGenericInterfaces()[0]));
 @SuppressWarnings("rawtypes") // Trying to test raw class
 TypeToken<Second> tokS = new TypeToken<Second>() {};
 assertTrue(tokS.isSupertypeOf(Second.class));
 assertTrue(tokS.isSupertypeOf(Third.class.getGenericSuperclass()));
}

/**
 * Determine whether the underlying type has any unresolvable generics:
 * either through an unresolvable type variable on the type itself
 * or through implementing a generic interface in a raw fashion,
 * i.e. without substituting that interface's type variables.
 * The result will be {@code true} only in those two scenarios.
 */
public boolean hasUnresolvableGenerics() {
  if (this == NONE) {
    return false;
  }
  ResolvableType[] generics = getGenerics();
  for (ResolvableType generic : generics) {
    if (generic.isUnresolvableTypeVariable() || generic.isWildcardWithoutBounds()) {
      return true;
    }
  }
  Class<?> resolved = resolve();
  if (resolved != null) {
    for (Type genericInterface : resolved.getGenericInterfaces()) {
      if (genericInterface instanceof Class) {
        if (forClass((Class<?>) genericInterface).hasGenerics()) {
          return true;
        }
      }
    }
    return getSuperType().hasUnresolvableGenerics();
  }
  return false;
}