java中的反射的学习笔记

一、反射的概述

1.关于反射的理解

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
框架 = 反射 + 注解 +设计模式

2.体会反射机制的“动态性”

//反射的动态性
    @Test
    public void test2(){
        int num = new Random().nextInt(3);//0,1,2
        String classPath = "";
        switch (num){
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.atguigu.java.Person";
                break;
        }

        try {
            Object obj = getInstance(classPath);
            System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*
    创建一个指定类的对象。
    classPath:指定类的全类名
     */
    public Object getInstance(String classPath) throws Exception {
        Class clazz = Class.forName(classPath);
        return clazz.newInstance();
    }

4. 反射机制能提供的功能

① 在运行时判断任意一个对象所属的类
② 在运行时构造任意一个类的对象
③ 在运行时判断任意一个类所具有的成员变量和方法
④ 在运行时获取泛型信息
⑤ 在运行时调用任意一个对象的成员变量和方法
⑥ 在运行时处理注解
⑦ 生成动态代理

5.相关API

java.lang.Class:反射的源头
java.lang.reflect.Method
java.lang.reflect.Field
java.lang,reflecr.Consturctor
…

二、Class类的理解与获取Class的实例

1.Class类的理解

1. 类的加载过程：
   程序经过javac.exe命令以后，会生成一个或多个字节码文件（.calss结尾）,接着我们使用java.exe命令对某个字节码文件进行解释运行。
   相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类。
   此运行时类，就作为Class的一个实例。
2. 换句话说，Class的实例就对应着一个运行时类。
3. 加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。

2.获取Class实例的几种方式

 //方式一：调用运行时类的属性:.calss
      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("com.atguigu.java.Person");
      System.out.println(clazz3);

//方式四：使用类的加载器：ClassLoader（了解）
      ClassLoader classLoader = ReflectionTest.class.getClassLoader();
      Class clazz4 = classLoader.loadClass("com.atguigu.java.Person");
      System.out.println(clazz4);

3.总结：创建类的对象的方式？

方式一： new + 构造器
方式二：要创建Xxx类的对象，可以考虑：Xxx、Xxxs、XxxFactory、XxxBuilder类中查看是否有静态方法的存在。可以调用其静态方法，创建Xxx对象。
方式三：通过反射

三、反射应用一：创建运行时类的对象

1.代码举例

		Class<Person> clazz = Person.class;
        Person obj = clazz.newInstance();
        System.out.println(obj);

2.说明

    newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参构造器

    要想此方法正常创建运行时类的对象，要求：
    1.运行时类必须提供空参的构造器
    2.保证足够的空参的构造器的访问权限。通常，设置为public。


    在javabean中要求提供一个public的空参构造器。原因：
    1.便于通过反射，创建运行时类的对象
    2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器

四、反射应用二：创建运行时类的完整结构

/*
    @Xxx
    权限修饰符 返回值类型 方法名（参数类型1 形参名,...) throws XxxException{}
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            //1.获取声明方法的注解
            Annotation[] annos = m.getAnnotations();
            for (Annotation a : annos) {
                System.out.println(a);
            }

            //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[] parameterTypes = m.getParameterTypes();
            if(!(parameterTypes == null && parameterTypes.length == 0)){
                for (int i = 0; i < parameterTypes.length; i++) {
                    if(i == parameterTypes.length -1){
                        System.out.print(parameterTypes[i].getName()+" args_"+i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName()+" args_"+i+",");
                }
            }
            System.out.print(")");

            //6.抛出的异常
            Class[] exceptionTypes = m.getExceptionTypes();
//            if(!(exceptionTypes == null && exceptionTypes.length == 0)){
//                System.out.print("throws ");
//                for (int i = 0; i < exceptionTypes.length; i++) {
//                    if(i == exceptionTypes.length-1){
//                        System.out.print(exceptionTypes[i]);
//                        break;
//                    }
//                    System.out.print(exceptionTypes[i].getName()+",");
//                }
//            }
            if(exceptionTypes.length > 0){
                System.out.print("throws ");
                for (int i = 0; i < exceptionTypes.length; i++) {
                    if(i == exceptionTypes.length-1){
                        System.out.print(exceptionTypes[i]);
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName()+",");
                }
            }

            System.out.println();
        }

五、反射应用三：调用运行时类的指定结构

调用指定的属性：

@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,"Tom");

        System.out.println(name.get(p));
    }
``
## 调用指定的方法：
```java
 @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()
         invoke():参数1：方法的调用者 参数2：给方法参数赋值的实参
         invoke()的返回值即为对应类中调用方法的返回值。
          */
         Object returnValue = show.invoke(p, "CHN");
         System.out.println(returnValue);

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

         //private static void showDesc()

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

     }
``
## 调用指定的构造器：
```java
@Test
    public void testConstructor() throws Exception{
        Class clazz = Person.class;

        //private Person(String name)
         /*
         1.获取指定的构造器
         getDeclaredConstructor()：参数：指明构造器的参数列表
          */

        Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class);

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

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