[JAVA]反射——Java学习笔记（二）

反射

1、获取Calss实例的四种方式

//方式一：调用运行时类的属性
Class clzz = Person.calss;
//方式二：通过运行时类的对象
Person p = new Person;
Class clzz = p.getClass();
//方式三：调用Class的静态方法：forName(String classPath)
Class.forName("com.longge.java.Person");
//方式四：使用类的加载器：
ClassLoader classLoader = TestClass.class.getClassLoader();
Class clzz = classLoader.loadClass("com.longge.java.Person");

2、读取配置文件的两种方式

Properties pros = new Properties;
//方式一：直接获取输入流
FileInputStream fis = new FileInputStream("jdbc.properties");
pros.load(fis);
//方式二：使用类加载器获取输入流
ClassLoader calssloder = ClassLoderTest.class.getClassLoader();
InputStream is = classloader.getResourceAsStream("jdbc.properties");
pros.load(is);
//读取配置属性
String user = pros.getProperty("user");

3、通过反射创建运行时类的对象

Class<Person> clazz = Person.class;
//newInstance()内部调用了运行时类的空参构造器
Person obj = clazz.newInstance();
//还可以通过调用getDclaredConstractor使用运行时类的其他构造器

4、获取运行时类的完整结构

4.1、获取属性

Class<Person> clazz = Person.class;
//获取属性结构
Field[] fields = clazz.getFields();//getFields():获取当前运行时类以及父类中声明为public访问权限的属性
Field[] fields = clazz.getDeclaredFields();//getDeclaredFields():获取当前运行时类所有的属性不包含父类

//属性的权限修饰符
//返回数字
int modifier = fields[i].getModifiders

//属性的数据类型
Class type = fields[i].getType();

//属性名
String name = fields[i].getName();

4.2、获取方法

//获取方法
Method[] methods = clazz.getMethods();
Method[] methods = clazz.getDeclaredMethods();

for (Method m : declaredMethods) {
    //1.获取方法声明的注解
    Annotation[] annos = m.getAnnotations();
    for (Annotation a : annos) {
        System.out.println(a + "KKKK");
    }
    
    //2.权限修饰符
    System.out.print(Modifier.toString(m.getModifiers()) + "\t");
    
    //3.返回值类型
    System.out.print(m.getReturnType().getName() + "\t");
    
    //4.方法名
    System.out.print(m.getName());
    System.out.print("(");
    //5.形参列表
    Class[] pTs = m.getParameterTypes();
    if(!(pTs == null && pTs.length == 0)){
        for(int i = 0;i < pTs.length;i++){
            if(i == pTs.length - 1){
                System.out.print(pTs[i].getName() + " args_" + i);
                break;
            }
            System.out.print(pTs[i].getName() + " args_" + i + ",");
        }
    }
    System.out.print(")");
    
    //6.抛出的异常
    Class[] eTs = m.getExceptionTypes();
    if(eTs.length > 0){
        System.out.print("throws ");
        for(int i = 0;i < eTs.length;i++){
            if(i == eTs.length - 1){
                System.out.print(eTs[i].getName());
                break;
            }
            System.out.print(eTs[i].getName() + ",");
        }
    }
    System.out.println("TQA");
}

4.3、获取构造器

 /**
     * 获取构造器的结构
     */
    @Test
    public void test(){
        Class clazz = Person.class;
        //getConstructors():获取当前运行时类中声明为public的构造器
        Constructor[] constructors = clazz.getConstructors();
        for(Constructor c : constructors){
            System.out.println(c);
        }
        System.out.println("************************");
        //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c : declaredConstructors){
            System.out.println(c);
        }
    }

4.4、获取父类以及父类的泛型

/**
     * 获取运行时类的父类
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);
    }

    /**
     * 获取运行时类的带泛型的父类
     */
    @Test
    public void test3(){
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
    }

    /**
     * 获取运行时类的带泛型的父类的泛型
     */
    @Test
    public void test4(){
        Class clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        //获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
//        System.out.println(actualTypeArguments[0].getTypeName());
        System.out.println(((Class)actualTypeArguments[0]).getName());
    }

4.5、获取接口、所在包、注解等

 /**
     * 获取运行时类实现的接口
     */
    @Test
    public void test5(){
        Class clazz = Person.class;

        Class[] interfaces = clazz.getInterfaces();
        for(Class c : interfaces){
            System.out.println(c);
        }
        System.out.println("++++++++++++++++++++++");
       
        //获取运行时类的父类实现的接口
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for(Class c : interfaces1){
            System.out.println(c);
        }
    }

    /**
     * 获取运行时类所在的包
     */
    @Test
    public void test6(){
        Class clazz = Person.class;
        Package pack = clazz.getPackage();
        System.out.println(pack);
    }

    /**
     * 获取运行时类声明的注解
     */
    @Test
    public void test7(){
        Class clazz = Person.class;
        Annotation[] annotations = clazz.getAnnotations();
        for(Annotation annos : annotations){
            System.out.println(annos);
        }
    }

5、调用运行时类的指定结构

5.1、调用指定的属性

/**
 * 调用运行时类中指定的结构：属性、方法、构造器
 */
public class ReflectionTest {
    /**
     * 不需要掌握
     */
    @Test
    public void testField() throws Exception {
        Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        //获取指定的属性：要求运行时类中属性声明为public
        //通常不采用此方法
        Field id = clazz.getField("id");

        //设置当前属性的值
        //set():参数1：指明设置哪个对象的属性   参数2：将此属性值设置为多少
        id.set(p,1001);

        //获取当前属性的值
        //get():参数1：获取哪个对象的当前属性值
        int pId = (int) id.get(p);
        System.out.println(pId);
    }

    /**
     * 如何操作运行时类中的指定的属性 -- 需要掌握
     */
    @Test
    public void testField1() throws Exception {
        Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        //1. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");

        //2.保证当前属性是可访问的
        name.setAccessible(true);

        //3.获取、设置指定对象的此属性值
        name.set(p,"Jam");
        System.out.println(name.get(p));
    }
}

5.2、调用指定的方法

public class ReflectionTest {
    /**
     * 如何操作运行时类中的指定的方法 -- 需要掌握
     */
    @Test
    public void testMethod() throws Exception {
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        //1.获取指定的某个方法
        //getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
        Method show = clazz.getDeclaredMethod("show", String.class);

        //2.保证当前方法是可访问的
        show.setAccessible(true);

        //3.调用方法的invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参
        //invoke()的返回值即为对应类中调用的方法的返回值。
        Object returnValue = show.invoke(p,"CCA"); //String nation = p.show("CCA");
        System.out.println(returnValue);

        System.out.println("+++++++++如何调用静态方法+++++++++++");

//    private static void showDesc()

        Method showDesc = clazz.getDeclaredMethod("showDown");
        showDesc.setAccessible(true);
        //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
//    Object returnVal = showDesc.invoke(null);
        Object returnVal = showDesc.invoke(Person.class);
        System.out.println(returnVal);//null
    }

5.3、调用指定的构造器

 /**
     * 如何调用运行时类中的指定的构造器
     */
    @Test
    public void testConstructor() throws Exception {
        Class clazz = Person.class;

        //private Person(String name)
        //1.获取指定的构造器
        //getDeclaredConstructor():参数：指明构造器的参数列表
        Constructor constructor = clazz.getDeclaredConstructor(String.class);

        //2.保证此构造器是可访问的
        constructor.setAccessible(true);

        //3.调用此构造器创建运行时类的对象
        Person per = (Person) constructor.newInstance("Tom");
        System.out.println(per);
    }