java反射机制小复习

反射相关的主要API

java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器

反射的相关操作

获取Class实例的方式

//方式一:调用运行时类的属性：.class(可以通过泛型进行约束)
Class clazz1 = Person.class;
System.out.println(clazz1);
//方式二：通过运行时类的对象
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);
//方式三：调用Class的静态方法：forName(String classPath)(重要)
Class clazz3 = Class.forName("类的完整名称");
System.out.println(clazz3);
//了解即可
//方式四：类的加载器：ClassLoder
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("类的完整名称");
System.out.println(clazz4);

获取对应类的对象

//IllegalAccessException, InstantiationException
//非法访问异常和实例化异常
//newInstance();调用此方法创建对应运行时类的对象，内部是调用类的空参构造器
//通过此方法创建对象的时候需要注意，该类要有空参构造器，且访问权限得符合
Class clazz = Person.class;
Object obj = clazz.newInstance();

获取类的结构

1. 获取所有属性(包括父类的),但是只能获得public修饰的属性
   Field[] fields = clazz.getFields();
2. 获取所有自己所声明的属性，可以获得任何修饰符
   Field[] f1 = clazz.getDeclaredFields();
3. 获取所有方法（包括所有父类中的所有方法）但是只有public属性修饰的方法
   Method[] methods = clazz.getMethods();
4. 获取所有方法（获取自身所有说明的方法）不包含父类的
   Method[] declaredMethods = clazz.getDeclaredMethods();
5. 获取运行的当前实例中public的构造器
   Constructor[] constructors = clazz.getConstructors();
6. 获取当前运行实例中所有声明的构造器
   Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
7. 获取运行时类的接口
   Class[] interfaces = clazz.getInterfaces();
8. 通过获得的属性、方法、构造器
   通过getDeclaringClass()方法都可以获得当前类的字节码对象
   getSimpleName()可以获得当前类的简单名称

Class clazz = Person.class;
//获取属性结构
//获取所有属性(包括父类的),但是只能获得public修饰的属性
Field[] fields = clazz.getFields();
//获取所有自己所声明的属性，可以获得任何修饰符
Field[] f1 = clazz.getDeclaredFields();
	//通过属性对象获取权限修饰符、数据类型、变量名
	//获取权限修饰符（public 1 protected 4 default 0 private 2 static 8）
	int modifiers = f.getModifiers();
	System.out.println(Modifier.toString(modifiers));
	//获取数据类型
	Class type = f.getType();
	System.out.println("type = " + type.getName() + "\t");
	//获取变量名
	String name = f.getName();
	System.out.println("name = " + name);
//获取运行时类的方法结构
Class clazz = Class.forName("com.qianfeng.entity.Student");
//获取所有方法（包括所有父类中的所有方法）但是只有public属性修饰的方法
Method[] methods = clazz.getMethods();
//获取所有方法（获取自身所有说明的方法）不包含父类的
Method[] declaredMethods = clazz.getDeclaredMethods();
//获取注解、权限修饰符、返回值类型、方法名、异常类型
for (Method m : declaredMethods) {
    //获取方法声明的注解
    Annotation[] annotations = m.getAnnotations();
    //获取方法声明的权限修饰符
    int modifiers = m.getModifiers();
    System.out.println(Modifier.toString(modifiers));
    //获取返回值类型
    String name = m.getReturnType().getName();
    System.out.println("name = " + name);
    //获取方法名
    String name1 = m.getName();
    System.out.println("name1 = " + name1);
    //获取形参列表
    Class[] parameterTypes = m.getParameterTypes();
    System.out.println(Arrays.toString(parameterTypes));
    //获取抛出的异常
    Class[] exceptionTypes = m.getExceptionTypes();
}
//获取运行时类的方法结构
Class clazz = Class.forName("com.qianfeng.entity.Student");
//获取运行的当前实例中public的构造器
Constructor[] constructors = clazz.getConstructors();
//获取当前运行实例中所有声明的构造器
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
//获取运行时类的父类
Class superclass = clazz.getSuperclass();
//获取运行时类的带泛型的父类
Type genericSuperclass = clazz.getGenericSuperclass();
//获取运行时类的带泛型的父类的泛型
Type[] actualTypeArguments = ((ParameterizedType) clazz.getGenericSuperclass()).getActualTypeArguments();
//获取运行时类的接口
Class[] interfaces = clazz.getInterfaces();
//获取运行时类所在的包
Package aPackage = clazz.getPackage();
//获取运行时类所声明的注解
Annotation[] annotations = clazz.getAnnotations();

调用运行时类的指定的结构（属性方法构造器）

调用指定的属性

//获取Class对象
Class clazz = Class.forName("com.qianfeng.entity.Student");
//创建运行时类的对象
Student s = (Student)clazz.newInstance();
//        //获取指定的属性(要求属性设置为public)（通常不使用）
//        Field s_id = clazz.getField("s_id");
//获取指定的属性
Field s_id = clazz.getDeclaredField("s_id");
//包装当前属性是可访问的
s_id.setAccessible(true);
//设置当前属性的值
s_id.set(s,"1001");
//获取当前属性的值
String o = (String) s_id.get(s);
System.out.println("o = " + o);

调用指定的方法

//获取Class对象
Class clazz = Class.forName("com.qianfeng.entity.Student");
//创建运行时类的对象
Student s = (Student)clazz.newInstance();
//获取指定的某个方法
//参数一指明获取方法的名称 参数二指明获取的方法的形参列表
Method setS_id = clazz.getDeclaredMethod("setS_id", String.class);
//保证方法可访问
setS_id.setAccessible(true);
//调用指定方法
//参数一方法的调用对象 参数二给方法形参赋值的实参
setS_id.invoke(s,"1001");
System.out.println(s);
//调用静态方法的时候
名字.invoke(类名.class)或者.invoke(null)（其实填什么都无所谓，因为它都不会去识别）;

调用指定的构造器

//获取Class对象
Class clazz = Class.forName("com.qianfeng.entity.Student");
//获取指定的构造器
//参数：构造器的参数列表如String.class....
Constructor declaredConstructor = clazz.getDeclaredConstructor();
//保证构造器可访问
declaredConstructor.setAccessible(true);
//调用构造器
Student s = (Student) declaredConstructor.newInstance();

通过反射动态的创建对象

package com.qianfeng.Test;

import java.util.Random;

public class Test02 {
    public static void main(String[] args) {
        int num = new Random().nextInt(3);
        String classPath = "";
        switch (num){
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.qianfeng.entity.Student";
                break;
        }
        Object obj = null;
        try {
            obj = instanceObject(classPath);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("obj = " + obj);
    }

    public static Object instanceObject(String classPath) throws Exception {
        Class clazz = Class.forName(classPath);

        return clazz.newInstance();
    }
}

Class clazz = Person.class;
clazz.getConstructor(String.class,int.class)
Class: