获取继承关系

java中没有多继承, 故一个类最多只有一个父类, 但可实现多个接口. 利用反射可获取类的信息(属性, 方法, 继承关系)

获取类自身

Class cz1 = String.class;
Class cz2 = "abc".getClass();
Class cz3;
try {
    cz3 = Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
    throw new RuntimeException(e);
}
System.out.println(cz1);   // class java.lang.String
System.out.println(cz2);   // class java.lang.String
System.out.println(cz3);   // class java.lang.String

其中通过Class.forName​获取类类型, 需要传递完整的包名

获取父类

getSuperclass

获取的父类不带泛型

 Class cz = Integer.class.getSuperclass();
 System.out.println(cz);  // class java.lang.Number

getGenericSuperclass

可获得带泛型的父类

public class Test {
    public static class T<T1, T2> {}
    public static class Template extends T<Integer, String> {}

    public static void main(String[] args) {
        Template tt = new Template();
  
        Class clazz = tt.getClass();
        System.out.println(clazz);
   
        System.out.println(clazz.getSuperclass());   
        // getGenericSuperclass() 获得该类带有泛型的父类
        Type type = clazz.getGenericSuperclass();
        System.out.println(type);
        // ParameterizedType 参数化类型，即泛型
        // 将Type转化为参数化类型(即泛型)
        ParameterizedType p = (ParameterizedType) type;
        // getActualTypeArguments() 获取参数化类型的数组，泛型可能有多个
        Type[] actualTypeArguments = p.getActualTypeArguments();
        // 将Type转化为类型变量(即Class)
        Class c1 = (Class) actualTypeArguments[0];
        Class c2 = (Class) actualTypeArguments[1];
        System.out.println(c1);
        System.out.println(c2);
    }
}

class Test$Template
class Test$T
Test$T<java.lang.Integer, java.lang.String>
class java.lang.Integer
class java.lang.String

getSuperclass与getGenericSuperclass的区别:

• getSuperclass: 获取直接父类
• getGenericSuperclass: 获取带泛型的父类(没有泛型获取的就是直接父类的类型)
• 返回类型不同: getSuperclass为Class, getGenericSuperclass为Type

判断类型是否可转

实例类型转换

Object obj = "abc";
String str  = null;
if(obj instanceof String) {
     str = (String) obj;
}

类类型转型

Object.class.isAssignableFrom(String.class)

判断String是否可转为类型Object

获取接口列表

getInterfaces

由于类可继承多个接口, 故getInterfaces​返回的是一个类数组

Class s = Integer.class;
Class[] czs = s.getInterfaces();
for (Class cz : czs) {
    System.out.println(cz);
}

interface java.lang.Comparable
interface java.lang.constant.Constable
interface java.lang.constant.ConstantDesc

getGenericInterfaces

返回的接口带泛型参数

class InterfaceDemo<K,V> implements Serializable,Cloneable, Map<K, V> { ... }
InterfaceDemo<Integer,String> iDemo = new InterfaceDemo();
for(Class t : iDemo.getClass().getInterfaces()) {
    System.out.println(t);
}
System.out.println("--------------------------");
for(Type t : iDemo.getClass().getGenericInterfaces()) {
    System.out.println(t);
}

interface java.io.Serializable
interface java.lang.Cloneable
interface java.util.Map
--------------------------
interface java.io.Serializable
interface java.lang.Cloneable
java.util.Map<K, V>