示例对象

public class User {
    public static final String UP = "游客";
    public String username = "admin";
    private int age;
    public User() {
    }
    public User(String username, int age) {
        this.username = username;
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    private void setAge(int age) {
        this.age = age;
    }
}

Class 类

获取Class的方法

public static void main(String[] args) throws Exception {
    //这三种方法都会执行静态代码块
    Class clazz = User.class;
    Class clazz = Class.forName("com.tenbeggar.User");
    Class clazz = new User().getClass();
}

反射实例化对象

public static void main(String[] args) throws Exception {
    //该方法实际上调用了对象的无参数构造方法，必须有无参构造器方可使用
    User user = User.class.newInstance();
}

获取类路径

public static void main(String[] args) throws Exception {
    //普通类
    User.class.getSimpleName();//User
    User.class.getName();User.class.getTypeName();User.class.getCanonicalName();//com.tenbeggar.User
    //数组
    User[].class.getSimpleName();//User[]
    User[].class.getName();//[Lcom.tenbeggar.User;
    User[].class.getTypeName();User[].class.getCanonicalName();//com.tenbeggar.User[]
    //成员内部类
    User.Password.class.getSimpleName();//Password
    User.Password.class.getName();User.Password.class.getTypeName();//com.tenbeggar.User$Password
    User.Password.class.getCanonicalName();//com.tenbeggar.User.Password
}

获取父类或接口

public static void main(String[] args) throws Exception {
    Class clazz = User.class;
    Class superclass = clazz.getSuperclass();//获取调用类的父类
    Type genericSuperclass = clazz.getGenericSuperclass();//获取调用类的父类(含泛型)
    Class[] interfaces = clazz.getInterfaces();//获取调用类实现的接口列表
    Type[] genericInterfaces = clazz.getGenericInterfaces();//获取调用类实现的接口列表(含泛型)
}

Filed 字段

获取Filed的方法

public static void main(String[] args) throws Exception {
    Class clazz = User.class;
    Field[] fields = clazz.getFields();//不能获取被private修饰的属性
    Field field = clazz.getField("username");//获取属性名为username的Filed
    Field[] declaredFields = clazz.getDeclaredFields();//可以获取被private修饰的属性
    Field declaredField = clazz.getDeclaredField("age");
}

Filed的方法

public static void main(String[] args) throws Exception {
    User user = new User();
    Field field = User.class.getField("username");
    String name = field.getName();//获取属性名 username
    int modifiers = field.getModifiers();//获取属性修饰符 1
    Class type = field.getType();//获取属性类型 java.lang.String
    field.set(user, "root");//设置属性值
    Object o = field.get(user);//获取属性值 root
}

set方法不能设置私有属性，解决办法如下：

public static void main(String[] args) throws Exception {
    User user = new User();
    Field field = User.class.getDeclaredField("age");
    field.setAccessible(true);//设置为true可以打破封装
    field.set(user, 20);
}

Method 方法

获取Method的方法

public static void main(String[] args) throws Exception {
    Class clazz = User.class;
    Method[] methods = clazz.getMethods();//获取当前类及其父类的方法
    Method method = clazz.getMethod("getAge");//获取方法名为getAge的Method
    Method[] declaredMethods = clazz.getDeclaredMethods();//获取当前类的方法
    Method declaredMethod = clazz.getDeclaredMethod("setAge", int.class);
}

Method的方法

public static void main(String[] args) throws Exception {
    User user = new User();
    Class clazz = User.class;
    Method declaredMethod = clazz.getDeclaredMethod("setAge", int.class);
    declaredMethod.invoke(user, 20);//执行setAge方法
    Method method = clazz.getMethod("getAge");
    Object invoke = method.invoke(user);//执行getAge方法并获取返回值 20
}

Constructor 构造器

获取Constructor的方法

public static void main(String[] args) throws Exception {
    Class clazz = User.class;
    Constructor[] constructors = clazz.getConstructors();//不能获取被private修饰的构造器
    Constructor constructor = clazz.getConstructor();//获取无参构造器Constructor
    Constructor[] declaredConstructors = clazz.getDeclaredConstructors();//可以获取被private修饰的构造器
    Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class, int.class);
}

Constructor的方法

public static void main(String[] args) throws Exception {
    Class clazz = User.class;
    Constructor constructor = clazz.getConstructor();
    User user = constructor.newInstance();//无参构造器
    Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class, int.class);
    User root = declaredConstructor.newInstance("root", 20);//全参构造器
}

获取泛型类型的工具类

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
public class ReflectUtils {
    /**
     * 获取当前对象指定父类的泛型类型
     *
     * @param obj      指定对象
     * @param extClass 目标父类
     * @param i        泛型的index
     */
    public static  Class getObjectT(Object obj, Class extClass, int i) {
        Class subClass = isExtendsClass(obj.getClass(), extClass);
        ParameterizedType parameterizedType = (ParameterizedType) subClass.getGenericSuperclass();
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        return (Class) actualTypeArguments[i];
    }
    /**
     * 获取当前类指定父类的下一级子类
     *
     * @param thisClass 当前对象
     * @param extClass  目标父类
     */
    private static Class isExtendsClass(Class thisClass, Class extClass) {
        Class superClass = thisClass.getSuperclass();
        if (superClass == Object.class) {
            throw new IllegalStateException("Not find extends class.");
        } else {
            return superClass == extClass ? thisClass : isExtendsClass(superClass, extClass);
        }
    }
    /**
     * 获取当前类指定接口的泛型类型
     *
     * @param objClass       指定类
     * @param interfaceClass 目标接口
     * @param i              泛型的index
     */
    public static  Class getInterfaceT(Class objClass, Class interfaceClass, int i) {
        Type[] genericInterfaces = objClass.getGenericInterfaces();
        ParameterizedType targetInterface = null;
        for (Type genericInterface : genericInterfaces) {
            ParameterizedType pt = (ParameterizedType) genericInterface;
            if (pt.getRawType() == interfaceClass) {
                targetInterface = pt;
            }
        }
        if (targetInterface == null) {
            throw new IllegalStateException("Not find target interface.");
        }
        Type[] actualTypeArguments = targetInterface.getActualTypeArguments();
        return (Class) actualTypeArguments[i];
    }
}