Java程序设计（高级及专题）- 类的加载和反射

Bertha 。 2022-01-31 19:45 39阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]

# 加载器 #

类加载器就是可以从其作用来理解，其功能就是将classpath目录下.class文件,加载到内存中来进行一些处理,处理完的结果就是一些字节码.那是谁把这些class类加载到内存中来的呢?就是类加载器。

## JVM中默认的类加载器 ##

java虚拟机中可以安装多个类加载器,系统默认三个主要的类加载器,每个类加载器负责加载不同位置的类:BootStrap,ExtClassLoader,AppClassLoader

注意的是：  
1.类加载器本身也是一个java类,因为类加载器本身也是一个java类,那么这个特殊的java类【类加载器】是有谁加载进来的呢?这显然要有第一个类加载器，这第一个类加载器不是一个java类，它是BootStrap。  
2.BootStrap不是一个java类，不需要类加载器java加载，他是嵌套在java虚拟机内核里面的。java 虚拟机内核已启动的时候，他就已经在那里面了，他是用c++语言写的一段二进制代码。他可以去加载别的类，其中别的类就包含了类加载器【如上面提到的Ext 和 app】。  
案例：获取ClassLoaderTest这个类的类加载器的名字

package study.javaenhance;
     
    import java.util.ArrayList;
     
    public class ClassLoaderTest
    { 
      public static void main(String[] args) throws Exception 
      { 
        //获取类加载器,那么这个获取的是一个实例对象,我们知道类加载器也有很多种,那么因此也有其对应的类存在,因此可以获取到对应的字节码
        System.out.println(ClassLoaderTest.class.getClassLoader());
        //获取类加载的字节码,然后获取到类加载字节码的名字
        System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());
        //下面我们看下获取非我们定义的类,比如System ArrayList 等常用类
        System.out.println(System.class.getClassLoader()); 
        System.out.println(ArrayList.class.getClassLoader());  
      }
     
    }

控制台输出：

sun.misc.Launcher$AppClassLoader@1c78e57
    sun.misc.Launcher$AppClassLoader
    null
    null

分析：  
ClassLoaderTest的类加载器的名称是AppClassLoader。也就是这个类是由AppClassLoader这个类加载器加载的。  
System/ArrayList的类加载器是null。这说明这个类加载器是由BootStrap加载的。因为我们上面说了BootStrap不是java类，不需要类加载器加载。所以他的类加载器是null。

--------------------

java给我们提供了三种类加载器：BootStrap，ExtClassLoader，AppClassLoader。这三种类加载器是有父子关系组成了一个树形结构。BootStrap是根节点，BootStrap下面挂着ExtClassLoader，ExtClassLoader下面挂着AppClassLoader.  
案例：

package study.javaenhance;
    import java.util.ArrayList;
    public class ClassLoaderTest
    { 
      public static void main(String[] args) throws Exception 
      { 
        //获取类加载器,那么这个获取的是一个实例对象,我们知道类加载器也有很多种,那么因此也有其对应的类存在,因此可以获取到对应的字节码
        System.out.println(ClassLoaderTest.class.getClassLoader());
        //获取类加载的字节码,然后获取到类加载字节码的名字
        System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());
        //下面我们看下获取非我们定义的类,比如System ArrayList 等常用类
        System.out.println(System.class.getClassLoader()); 
        System.out.println(ArrayList.class.getClassLoader()); 
        //演示java 提供的类加载器关系
        ClassLoader classloader = ClassLoaderTest.class.getClassLoader();
        while(classloader != null)
        { 
          System.out.print(classloader.getClass().getName()+"-->");
          classloader = classloader.getParent();
        }
        System.out.println(classloader); 
         
      }

控制台输出：

sun.misc.Launcher$AppClassLoader-->sun.misc.Launcher$ExtClassLoader-->null

分析：  
通过这段程序可以看出来，ClassLoaderTest由AppClassLoader加载，AppClassLoader的父类节点是ExtClassLoader，ExtClassLoader的父节点是BootStrap。  
每一个类加载器都有自己的管辖范围。 BootStrap根节点，只负责加载rt.jar里的类，刚刚那个System就是属于rt.jar包里面的，ExtClassLoader负责加载JRE/lib/ext/\*.jar这个目录文件夹下的文件。而AppClassLoader负责加载ClassPath目录下的所有jar文件及目录。  
最后一级是我们自定义的加载器，他们的父类都是AppClassLoader。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70 1]

## 类加载器的双亲委派机制 ##

除了系统自带了类加载器，我们还可以自定义类加载器。然后把自己的类加载器挂在树上。作为某个类加载器的孩子。所有自定义类加载器都要继承ClassLoader。实现里面的一个方法ClassLoader（）。  
当Java虚拟机要加载第一个类的时候，到底派出哪个类加载器去加载呢？

(1). 首先当前线程的类加载器去加载线程中的第一个类(当前线程的类加载器：Thread类中有一个get/setContextClassLoader(ClassLoader cl);方法，可以获取/指定本线程中的类加载器)

(2). 如果类A中引用了类B,Java虚拟机将使用加载类A的类加载器来加载类B

(3). 还可以直接调用ClassLoader.loadClass(String className)方法来指定某个类加载器去加载某个类

每个类加载器加载类时，又先委托给其上级类加载器当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则会抛出ClassNotFoundException,不是再去找发起者类加载器的儿子，因为没有getChild()方法。例如：如上图所示： MyClassLoader->AppClassLoader->Ext->ClassLoader->BootStrap.自定定义的MyClassLoader1首先会先委托给AppClassLoader,AppClassLoader会委托给ExtClassLoader,ExtClassLoader会委托给BootStrap，这时候BootStrap就去加载，如果加载成功，就结束了。如果加载失败，就交给ExtClassLoader去加载，如果ExtClassLoader加载成功了，就结束了，如果加载失败就交给AppClassLoader加载，如果加载成功，就结束了，如果加载失败，就交给自定义的MyClassLoader1类加载器加载，如果加载失败，就报ClassNotFoundException异常，结束。

这样的好处在哪里呢？可以集中管理，不会出现多份字节码重复的现象。  
有两个类要再在System，如果让底层的类加载器加载，可能会出现两份字节码。而都让爷爷加载，爷爷加载到已有，当再有请求过来的时候，爷爷说：哎，我加载过啊，直接把那份拿出来给你用啊。就不会出现多份字节码重复的现象。

## 自定义类加载器 ##

自定义的类加载器必须继承抽象类ClassLoader然后重写findClass方法，其实他内部还有一个loadClass方法和defineClass方法，这两个方法的作用是：  
loadClass方法的源代码：

public Class<?> loadClass(String name) throws ClassNotFoundException {  
            return loadClass(name, false); 
          }

再来看一下loadClass(name,false)方法的源代码：

protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{  
         //加上锁，同步处理，因为可能是多线程在加载类 
         synchronized (getClassLoadingLock(name)) {  
           //检查，是否该类已经加载过了，如果加载过了，就不加载了 
           Class c = findLoadedClass(name); 
           if (c == null) {  
             long t0 = System.nanoTime(); 
             try {  
               //如果自定义的类加载器的parent不为null,就调用parent的loadClass进行加载类 
               if (parent != null) {  
                 c = parent.loadClass(name, false); 
               } else {  
                 //如果自定义的类加载器的parent为null，就调用findBootstrapClass方法查找类，就是Bootstrap类加载器 
                 c = findBootstrapClassOrNull(name); 
               } 
             } catch (ClassNotFoundException e) {  
               // ClassNotFoundException thrown if class not found 
               // from the non-null parent class loader 
             } 
      
             if (c == null) {  
               // If still not found, then invoke findClass in order 
               // to find the class. 
               long t1 = System.nanoTime(); 
               //如果parent加载类失败，就调用自己的findClass方法进行类加载 
               c = findClass(name); 
      
               // this is the defining class loader; record the stats 
               sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); 
               sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1); 
               sun.misc.PerfCounter.getFindClasses().increment(); 
             } 
           } 
           if (resolve) {  
             resolveClass(c); 
           } 
           return c; 
         } 
       }

在loadClass代码中也可以看到类加载机制的原理，这里还有这个方法findBootstrapClassOrNull,看一下源代码：

private Class findBootstrapClassOrNull(String name) 
      {  
        if (!checkName(name)) return null; 
      
        return findBootstrapClass(name); 
      }

就是检查一下name是否是否正确，然后调用findBootstrapClass方法，但是findBootstrapClass方法是个native本地方法，看不到源代码了，但是可以猜测是用Bootstrap类加载器进行加载类的，这个方法我们也不能重写，因为如果重写了这个方法的话，就会破坏这种委托机制，我们还要自己写一个委托机制。

defineClass这个方法很简单就是将class文件的字节数组编程一个class对象，这个方法肯定不能重写，内部实现是在C/C++代码中实现的findClass这个方法就是根据name来查找到class文件，在loadClass方法中用到，所以我们只能重写这个方法了，只要在这个方法中找到class文件，再将它用defineClass方法返回一个Class对象即可。

这三个方法的执行流程是：每个类加载器：loadClass->findClass->defineClass

# Class对象 #

java中把生成Class对象和实例对象弄混了，更何况生成Class对象和生成 instance都有多种方式。所以只有弄清其中的原理，才可以深入理解。首先要生成Class对象，然后再生成Instance。那Class对象的生 成方式有哪些呢，以及其中是如何秘密生成的呢？

Class对象的生成方式如下：  
1.Class.forName(“类名字符串”) （注意：类名字符串必须是全称，包名+类名）  
2.类名.class  
3.实例对象.getClass()  
例如：

public class TestClass {  
        public  static void main(String[] args)  
        {   
        try {   
        //测试Class.forName() 
        Class testTypeForName=Class.forName("TestClassType");      
        System.out.println("testForName---"+testTypeForName);  
        //测试类名.class 
        Class testTypeClass=TestClassType.class;  
        System.out.println("testTypeClass---"+testTypeClass);  
        //测试Object.getClass() 
        TestClassType testGetClass= new TestClassType();  
        System.out.println("testGetClass---"+testGetClass.getClass());  
        } catch (ClassNotFoundException e) {   
        e.printStackTrace();  
        }  
        }  
        }  
         class TestClassType{   
        //构造函数 
        public TestClassType(){   
        System.out.println("----构造函数---"); 
        }  
        //静态的参数初始化 
        static{   
        System.out.println("---静态的参数初始化---");  
        }  
        //非静态的参数初始化 
        {    
        System.out.println("----非静态的参数初始化---"); 
        }     
        }

控制台输出如下：

---静态的参数初始化---
    testForName---class TestClassType
    testTypeClass---class TestClassType
    ----非静态的参数初始化---
    ----构造函数---
    testGetClass---class TestClassType

根据结果可以发现，三种生成的Class对象一样的。并且三种生成Class对象只打印一次“静态的参数初始化”。

我们知道，静态的方法属性初始化，是在加载类的时候初始化。而非静态方法属性初始化，是new类实例对象的时候加载。

因此，这段程序说明，三种方式生成Class对象，其实只有一个Class对象。在生成Class对象的时候，首先判断内存中是否已经加载。

所以，生成Class对象的过程其实是如此的：

当我们编写一个新的java类时,JVM就会帮我们编译成class对象,存放在同名 的.class文件中。在运行时，当需要生成这个类的对象，JVM就会检查此类是否已经装载内存中。若是没有装载，则把.class文件装入到内存中。若 是装载，则根据class文件生成实例对象。

# 反射 #

Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的內部信息，并能直接操作任意对象的内部属性及方法。  
Java反射机制主要提供了以下功能：

*  在运行时构造任意一个类的对象
 *  在运行时获取任意一个类所具有的成员变量和方法
 *  在运行时调用任意一个对象的方法（属性）
 *  生成动态代理

Class 是一个类;

*  一个描述类的类.
 *  封装了描述方法的 Method,
 *  描述字段的 Filed,
 *  描述构造器的 Constructor 等属性.  
    例如：描述方法-Method

public class ReflectionTest { 
        @Test
        public void testMethod() throws Exception{ 
            Class clazz = Class.forName("com.atguigu.java.fanshe.Person");
            
            //
            //1.获取方法
          // 1.1 获取取clazz对应类中的所有方法--方法数组（一）
            // 不能获取private方法,且获取从父类继承来的所有方法
            Method[] methods = clazz.getMethods();
            for(Method method:methods){ 
                System.out.print(" "+method.getName());
            }
            System.out.println();
            
            //
            // 1.2.获取所有方法，包括私有方法 --方法数组（二）
            // 所有声明的方法，都可以获取到，且只获取当前类的方法
            methods = clazz.getDeclaredMethods();
            for(Method method:methods){ 
                System.out.print(" "+method.getName());
            }
            System.out.println();
            
            //
            // 1.3.获取指定的方法
            // 需要参数名称和参数列表，无参则不需要写
            // 对于方法public void setName(String name) { }
            Method method = clazz.getDeclaredMethod("setName", String.class);
            System.out.println(method);
            // 而对于方法public void setAge(int age) { }
            method = clazz.getDeclaredMethod("setAge", Integer.class);
            System.out.println(method);
            // 这样写是获取不到的，如果方法的参数类型是int型
            // 如果方法用于反射，那么要么int类型写成Integer： public void setAge(Integer age) { }
    　　　　 // 要么获取方法的参数写成int.class
            
            //
            //2.执行方法
            // invoke第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数
            Object obje = clazz.newInstance();
            method.invoke(obje,2);
    
    　　　　//如果一个方法是私有方法，第三步是可以获取到的，但是这一步却不能执行
    　　　　//私有方法的执行，必须在调用invoke之前加上一句method.setAccessible（true）;
        }
    }

主要用到的两个方法:

/** * @param name the name of the method * @param parameterTypes the list of parameters * @return the {@code Method} object that matches the specified */
            public Method getMethod(String name, Class<?>... parameterTypes){ 
                
            }
            
            /** * @param obj the object the underlying method is invoked from * @param args the arguments used for the method call * @return the result of dispatching the method represented by */
            public Object invoke(Object obj, Object... args){ 
                
            }

## 自定义工具方法 ##

### 自定义一个方法 ###

比如Person里有一个方法

public void test(String name,Integer age){
            System.out.println("调用成功");
        }

*  把类对象和类方法名作为参数，执行方法

/** * * @param obj: 方法执行的那个对象. * @param methodName: 类的一个方法的方法名. 该方法也可能是私有方法. * @param args: 调用该方法需要传入的参数 * @return: 调用方法后的返回值 * */
          public Object invoke(Object obj, String methodName, Object ... args) throws Exception{ 
            //1. 获取 Method 对象
            // 因为getMethod的参数为Class列表类型，所以要把参数args转化为对应的Class类型。
            
            Class [] parameterTypes = new Class[args.length];
            for(int i = 0; i < args.length; i++){ 
                parameterTypes[i] = args[i].getClass();
                System.out.println(parameterTypes[i]); 
            }
            
            Method method = obj.getClass().getDeclaredMethod(methodName, parameterTypes);
            //如果使用getDeclaredMethod，就不能获取父类方法，如果使用getMethod，就不能获取私有方法
    　　　　
    　　　　　//
    　　　　　//2. 执行 Method 方法
            //3. 返回方法的返回值
            return method.invoke(obj, args);
          }

调用：通过对象名，方法名，方法参数执行了该方法

@Test
            public void testInvoke() throws Exception{ 
                Object obj = new Person();            
                invoke(obj, "test", "wang", 1);             
            }

# 2.把全类名和方法名作为参数，执行方法 #

/** * @param className: 某个类的全类名 * @param methodName: 类的一个方法的方法名. 该方法也可能是私有方法. * @param args: 调用该方法需要传入的参数 * @return: 调用方法后的返回值 */
            public Object invoke(String className, String methodName, Object ... args){ 
                Object obj = null;
                
                try { 
                    obj = Class.forName(className).newInstance();
                    //调用上一个方法
                    return invoke(obj, methodName, args);
                }catch(Exception e) { 
                    e.printStackTrace();
                }            
                return null;
            }

调用:

@Test
            public void testInvoke() throws Exception{ 
                invoke("com.atguigu.java.fanshe.Person", 
                        "test", "zhagn", 12);         
            }

使用系统方法（前提是此类有一个无参的构造器（查看API））

@Test
            public void testInvoke() throws Exception{ 
                Object result = 
                        invoke("java.text.SimpleDateFormat", "format", new Date());
                System.out.println(result);          
            }

这种反射实现的主要功能是可配置和低耦合。只需要类名和方法名，而不需要一个类对象就可以执行一个方法。如果我们把全类名和方法名放在一个配置文件中，就可以根据调用配置文件来执行方法.

## 如何获取父类定义的（私有）方法 ##

前面说一般使用getDeclaredMethod获取方法（因为此方法可以获取类的私有方法，但是不能获取父类方法）  
　　如何获取父类方法呢，上一个例子format方法其实就是父类的方法（获取的时候用到的是getMethod）  
　　首先我们要知道，如何获取类的父亲：  
　　比如有一个类，继承自Person  
　使用：

public class ReflectionTest { 
        @Test
        public void testGetSuperClass() throws Exception{ 
            String className = "com.atguigu.java.fanshe.Student";
            
            Class clazz = Class.forName(className);
            Class superClazz = clazz.getSuperclass();
            
            System.out.println(superClazz); 
        }
    }
    //结果是 “ class com.atguigu.java.fanshe.Person ”

此时如果Student中有一个方法是私有方法method1(int age); Person中有一个私有方法method2();  
　　怎么调用  
　　定义一个方法，不但能访问当前类的私有方法，还要能父类的私有方法.

/** * * @param obj: 某个类的一个对象 * @param methodName: 类的一个方法的方法名. * 该方法也可能是私有方法, 还可能是该方法在父类中定义的(私有)方法 * @param args: 调用该方法需要传入的参数 * @return: 调用方法后的返回值 */
        public Object invoke2(Object obj, String methodName, 
                Object ... args){ 
            //1. 获取 Method 对象
            Class [] parameterTypes = new Class[args.length];
            for(int i = 0; i < args.length; i++){ 
                parameterTypes[i] = args[i].getClass();
            }
            
            try { 
                Method method = getMethod(obj.getClass(), methodName, parameterTypes);
                method.setAccessible(true);
                //2. 执行 Method 方法
                //3. 返回方法的返回值
                return method.invoke(obj, args);
            } catch (Exception e) { 
                e.printStackTrace();
            }
            
            return null;
        }
        
        /** * 获取 clazz 的 methodName 方法. 该方法可能是私有方法, 还可能在父类中(私有方法) * 如果在该类中找不到此方法，就向他的父类找，一直到Object类为止 　　　* 这个方法的另一个作用是根据一个类名，一个方法名，追踪到并获得此方法 * @param clazz * @param methodName * @param parameterTypes * @return */
        public Method getMethod(Class clazz, String methodName, 
                Class ... parameterTypes){ 
            
            for(;clazz != Object.class; clazz = clazz.getSuperclass()){ 
                try { 
                    Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
                    return method;
                } catch (Exception e) { }            
            }
            
            return null;
        }

## 如何描述字段-Field ##

@Test
        public void testField() throws Exception{ 
            String className = "com.atguigu.java.fanshe.Person";        
            Class clazz = Class.forName(className); 
            
            //1.获取字段
          // 1.1 获取所有字段 -- 字段数组
            // 可以获取公用和私有的所有字段，但不能获取父类字段
            Field[] fields = clazz.getDeclaredFields();
            for(Field field: fields){ 
                System.out.print(" "+ field.getName());
            }
            System.out.println();
            
            // 1.2获取指定字段
            Field field = clazz.getDeclaredField("name");
            System.out.println(field.getName());
            
            Person person = new Person("ABC",12);
            
            //2.使用字段
          // 2.1获取指定对象的指定字段的值
            Object val = field.get(person);
            System.out.println(val);
            
            // 2.2设置指定对象的指定对象Field值
            field.set(person, "DEF");
            System.out.println(person.getName());
            
            // 2.3如果字段是私有的，不管是读值还是写值，都必须先调用setAccessible（true）方法
            // 比如Person类中，字段name字段是公用的，age是私有的
            field = clazz.getDeclaredField("age");
            field.setAccessible(true);
            System.out.println(field.get(person));        
        }

但是如果需要访问父类中的（私有）字段：

/** * //创建 className 对应类的对象, 并为其 fieldName 赋值为 val * //Student继承自Person,age是Person类的私有字段/ public void testClassField() throws Exception{ String className = "com.atguigu.java.fanshe.Student"; String fieldName = "age"; //可能为私有, 可能在其父类中. Object val = 20; Object obj = null; //1.创建className 对应类的对象 Class clazz = Class.forName(className); //2.创建fieldName 对象字段的对象 Field field = getField(clazz, fieldName); //3.为此对象赋值 obj = clazz.newInstance(); setFieldValue(obj, field, val); //4.获取此对象的值 Object value = getFieldValue(obj,field); } public Object getFieldValue(Object obj, Field field) throws Exception{ field.setAccessible(true); return field.get(obj); } public void setFieldValue(Object obj, Field field, Object val) throws Exception { field.setAccessible(true); field.set(obj, val); } public Field getField(Class clazz, String fieldName) throws Exception { Field field = null; for(Class clazz2 = clazz; clazz2 != Object.class;clazz2 = clazz2.getSuperclass()){ field = clazz2.getDeclaredField(fieldName); } return field; }

## 如何描述构造器-Constructor ##

@Test
        public void testConstructor() throws Exception{ 
            String className = "com.atguigu.java.fanshe.Person";
            Class<Person> clazz = (Class<Person>) Class.forName(className);
            
            //1. 获取 Constructor 对象
            // 1.1 获取全部
            Constructor<Person> [] constructors = 
                    (Constructor<Person>[]) Class.forName(className).getConstructors();
            
            for(Constructor<Person> constructor: constructors){ 
                System.out.println(constructor); 
            }
            
            // 1.2获取某一个，需要参数列表
            Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
            System.out.println(constructor); 
            
            //2. 调用构造器的 newInstance() 方法创建对象
            Object obj = constructor.newInstance("zhagn", 1);                
        }

## 如何描述注解 – Annotation ##

定义一个Annotation

import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(value={ ElementType.METHOD})
    public @interface AgeValidator { 
        public int min();
        public int max();
    }

此注解只能用在方法上

@AgeValidator(min=18,max=35)
        public void setAge(int age) { 
            this.age = age;
        }

那么我们在给Person类对象的age赋值时，是感觉不到注解的存在的

@Test
        public void testAnnotation() throws Exception{ 
            Person person = new Person();    
            person.setAge(10);
        }

必须通过反射的方式为属性赋值，才能获取到注解

/** Annotation 和 反射: * 1. 获取 Annotation * * getAnnotation(Class<T> annotationClass) * getDeclaredAnnotations() * */
        @Test
        public void testAnnotation() throws Exception{ 
            String className = "com.atguigu.java.fanshe.Person";
            
            Class clazz = Class.forName(className);
            Object obj = clazz.newInstance();    
            
            Method method = clazz.getDeclaredMethod("setAge", int.class);
            int val = 6;
            
            //获取指定名称的注解
            Annotation annotation = method.getAnnotation(AgeValidator.class);
            if(annotation != null){ 
                if(annotation instanceof AgeValidator){ 
                    AgeValidator ageValidator = (AgeValidator) annotation;                
                    if(val < ageValidator.min() || val > ageValidator.max()){ 
                        throw new RuntimeException("年龄非法");
                    }
                }
            }        
            method.invoke(obj, 20);
            System.out.println(obj);          
        }

如果在程序中要获取注解，然后获取注解的值进而判断我们赋值是否合法，那么类对象的创建和方法的创建必须是通过反射而来的。  
小结  
反射小结

*  Class: 是一个类; 一个描述类的类.  
    封装了描述方法的 Method,  
    描述字段的 Filed,  
    描述构造器的 Constructor 等属性.
 *  如何得到 Class 对象:  
    Person.class  
    person.getClass()  
    Class.forName(“com.atguigu.javase.Person”)
 *  关于 Method:
    
     *  如何获取 Method:  
        getDeclaredMethods: 得到 Method 的数组.  
        getDeclaredMethod(String methondName, Class … parameterTypes)
     *  如何调用 Method  
        　 如果方法时 private 修饰的, 需要先调用 Method 的　setAccessible(true), 使其变为可访问  
        　method.invoke(obj, Object … args);
 *  关于 Field:
    
     *  如何获取 Field: getField(String fieldName)
     *  如何获取 Field 的值:
        
         *  setAccessible(true)
         *  field.get(Object obj)
     *  如何设置 Field 的值:  
        　field.set(Obejct obj, Object val)
 *  了解 Constructor 和 Annotation
 *  反射和泛型.  
    　 getGenericSuperClass: 获取带泛型参数的父类, 返回值为: BaseDao<Employee, String>  
    　 Type 的子接口: ParameterizedType  
    　 可以调用 ParameterizedType 的 Type\[\] getActualTypeArguments() 获取泛型参数的数组.

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]: /images/20220126/91dfe8548252499293d1cfd2866df5a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70 1]: /images/20220126/26b241dd52644cfbbf315c8801791b52.png