码迷,mamicode.com
首页 > 编程语言 > 详细

Java反射学习:深入学习Java反射机制

时间:2018-06-03 17:37:56      阅读:212      评论:0      收藏:0      [点我收藏+]

标签:auth   rgs   jdk   person   tde   参考   xtend   它的   max   

一、Java反射的理解(反射是研究框架的基础之一)

 Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

二、逐步分析

参考:https://blog.csdn.net/u012585964/article/details/52011138

 

1、关于Class

  1、Class是一个类,一个描述类的类(也就是描述类本身),封装了描述方法的Method,描述字段的Filed,描述构造器的Constructor等属性
    2、对象照镜子后(反射)可以得到的信息:某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。
    3、对于每个类而言,JRE 都为其保留一个不变的 Class 类型的对象。 一个 Class 对象包含了特定某个类的有关信息。
    4、Class 对象只能由系统建立对象
    5、一个类在 JVM 中只会有一个Class实例

下面创建一个例子:后面的分析均以此案例为基准。

创建一个空接口:(后面会不断补充) 

1 package com.xfwl.reflection;
2 
3 public interface IHuman {
4 
5 }

 创建一个空基类:(后面会不断补充) 

1 package com.xfwl.reflection;
2 
3 public class Human {
4     
5 }

 创建一个子类:(后面会不断补充) 

 1 package com.xfwl.reflection;
 2 
 3 public class Person extends Human implements IHuman {
 4     /**
 5      * 默认default修饰
 6      */
 7     String name;
 8     /**
 9      * private修饰
10      */
11     private int age;
12     /**
13      * public修饰
14      */
15     public char sex=‘M‘;
16     /**
17      * 无参构造
18      */
19     public Person(){
20         System.out.println("无参构造!!!");
21     }
22     /**
23      * 有参构造
24      */
25     public Person(String name,int age,char sex){
26         System.out.println("有参构造!!!");
27         this.name=name;
28         this.age=age;
29         this.sex=sex;
30     }
31     public String getName() {
32         return name;
33     }
34     public void setName(String name) {
35         this.name = name;
36     }
37     public int getAge() {
38         return age;
39     }
40     public void setAge(int age) {
41         this.age = age;
42     }
43     public char getSex() {
44         return sex;
45     }
46     public void setSex(char sex) {
47         this.sex = sex;
48     }
49     public String toString() {  
50         return "Person{" +  
51                 "name=‘" + name + ‘\‘‘ +  
52                 ", age=" + age  +  
53                 ", sex=‘" + sex + ‘\‘‘ +  
54                 ‘}‘;  
55     }  
56 }

 2、反射获取类对象的三种方式(通过一个Junit测试来说明) 

 1 package com.xfwl.reflection;
 2 
 3 import org.junit.Test;
 4 /**
 5  * 测试类
 6  * @function  
 7  * @author 小风微凉
 8  * @time  2018-6-3 下午12:28:38
 9  */
10 public class TestAction {
11     /** 
12      * 反射机制获取类有三种方法 
13      */ 
14     @Test
15     public void testGetClass() throws ClassNotFoundException {  
16          Class clazz = null; 
17          
18         //1 直接通过类名.Class的方式得到  
19         clazz = Person.class;  
20         System.out.println("通过类名: " + clazz);  
21          
22         //2 通过对象的getClass()方法获取,这个使用的少(一般是传的是Object,不知道是什么类型的时候才用)  
23         Object obj = new Person();  
24         clazz = obj.getClass();  
25         System.out.println("通过getClass(): " + clazz);   
26          
27         //3 通过全类名获取,用的比较多,但可能抛出ClassNotFoundException异常  
28         clazz = Class.forName("com.xfwl.reflection.Person");  
29         System.out.println("通过全类名获取: " + clazz);           
30     }
31 }

 运行结果: 

通过类名: class com.xfwl.reflection.Person
无参构造!!!
通过getClass(): class com.xfwl.reflection.Person
通过全类名获取: class com.xfwl.reflection.Person

 特别注意:(以下2中方式不会调用构造方法,因为没有实例化操作)  

//1 直接通过类名.Class的方式得到  
clazz = Person.class; 
//3 通过全类名获取,用的比较多,但可能抛出ClassNotFoundException异常  
clazz = Class.forName("com.xfwl.reflection.Person");

3、利用newInstance创建对象:调用的类必须有无参的构造器

 1 /**
 2      * Class类的newInstance()方法,创建类的一个对象。
 3      * @throws ClassNotFoundException
 4      * @throws IllegalAccessException
 5      * @throws InstantiationException
 6      */
 7     @Test
 8     public void testNewInstance()  
 9             throws ClassNotFoundException, IllegalAccessException, InstantiationException {  
10       
11         Class clazz = Class.forName("com.xfwl.reflection.Person");  
12       
13         //使用Class类的newInstance()方法创建类的一个对象  
14         //实际调用的类的那个 无参数的构造器(这就是为什么写的类的时候,要写一个无参数的构造器,就是给反射用的)  
15         //一般的,一个类若声明了带参数的构造器,也要声明一个无参数的构造器  
16         Object obj = clazz.newInstance();  
17         System.out.println(obj);  
18     }  

 测试结果:

技术分享图片

那么,如果删除Person.java中的无参构造,继续测试,结果如下:

技术分享图片

4、ClassLoader类加载器

技术分享图片
类加载器详解:
http://blog.csdn.net/ochangwen/article/details/51473120
 
 1     /** 
 2      * ClassLoader类装载器 
 3      */  
 4     @Test  
 5     public void testClassLoader1() throws ClassNotFoundException, IOException {  
 6         //1、获取一个系统的类加载器  
 7         ClassLoader classLoader = ClassLoader.getSystemClassLoader();  
 8         System.out.println("系统的类加载器-->" + classLoader);  
 9       
10         //2、获取系统类加载器的父类加载器(扩展类加载器(extensions classLoader))  
11         classLoader = classLoader.getParent();  
12         System.out.println("扩展类加载器-->" + classLoader);  
13       
14         //3、获取扩展类加载器的父类加载器  
15         //输出为Null,无法被Java程序直接引用  
16         classLoader = classLoader.getParent();  
17         System.out.println("启动类加载器-->" + classLoader);  
18       
19         //4、测试当前类由哪个类加载器进行加载 ,结果就是系统的类加载器  
20         classLoader = Class.forName("com.xfwl.reflection.Person").getClassLoader();  
21         System.out.println("当前类由哪个类加载器进行加载-->"+classLoader);  
22       
23         //5、测试JDK提供的Object类由哪个类加载器负责加载的  
24         //输出为Null,无法被Java程序直接引用
25         classLoader = Class.forName("java.lang.Object").getClassLoader();  
26         System.out.println("JDK提供的Object类由哪个类加载器加载-->" + classLoader);  
27     } 

 测试结果: 

系统的类加载器-->sun.misc.Launcher$AppClassLoader@18b4aac2
扩展类加载器-->sun.misc.Launcher$ExtClassLoader@614c5515
启动类加载器-->null
当前类由哪个类加载器进行加载-->sun.misc.Launcher$AppClassLoader@18b4aac2
JDK提供的Object类由哪个类加载器加载-->null

 5、反射机制通过加载器获取流对象:getResourceAsStream方法 

 1 /**
 2      * 反射机制通过加载器获取流对象:getResourceAsStream方法
 3      * @throws ClassNotFoundException
 4      * @throws IOException
 5      */
 6      @Test  
 7     public void testGetResourceAsStream() throws ClassNotFoundException, IOException {  
 8         //调用getResourceAsStream 获取类路径下的文件对应的输入流 
 9          /**
10           * 特别说明:
11           * getResourceAsStream("path"),path的路径和new Person()的位置有关
12           */
13          
14         InputStream in = new Person().getClass().getClassLoader()  
15                 .getResourceAsStream("com/xfwl/reflection/test.properties");  
16         System.out.println("in: " +in);  
17   
18         Properties properties = new Properties(); 
19         properties.load(in);  
20         System.out.println("文件内容:"+properties);
21         System.out.println("name: "+properties.getProperty("name"));  
22         System.out.println("age: " + properties.getProperty("age"));
23         System.out.println("sex: "+properties.getProperty("sex"));  
24         System.out.println("desc: " + properties.getProperty("desc")); 
25     }  

 test.properties文件内容如下:文件编码格式:ISO-8859-1 

name=\u5C0F\u98CE\u5FAE\u51C9\u0087\u0089
age=23
sex=M
desc=\u53CD\u5C04\u673A\u5236\u5B66\u4E60

 运行结果:(直接解析会出现乱码问题,这个可以通过new String(乱码格式处理参数)来处理)

无参构造!!!
in: java.io.BufferedInputStream@215be6bb
文件内容:{age=23, name=小风微凉??, sex=M, desc=反射机制学习}
name: 小风微凉??
age: 23
sex: M
desc: 反射机制学习

 6、反射机制获取类中的方法:Method: 对应类中的方法 

现在给Person类添加一个private 方法、一个public 方法、一个defaut 方法、一个protected方法 

 1 /**
 2      * Java权限有四个,分别为public,protected,默认,private,其开放程度依次降低
 3      *    public可供所有类访问
 4      *    protected继承可见
 5      *    private只能类本身内部的方法可以访问
 6      */    
 7     public void method_public(){
 8         System.out.println("method_public");
 9     }
10     public void method_public_2(String name,int age,char sex){//public  带参数
11         System.out.println("method_public_2");
12         String info="Person{" +  
13         "name=‘" + name + ‘\‘‘ +  
14         ", age=" + age  +  
15         ", sex=‘" + sex + ‘\‘‘ +  
16         ‘}‘;
17         System.out.println(info);
18     }
19     protected void method_protected(){
20         System.out.println("method_protected");
21     }
22     protected void method_protected_2(String info){//protected  带参数
23         System.out.println("method_protected_2:"+info);
24     }
25     void method_default(){
26         System.out.println("method_default");
27     }
28     void method_default_2(String info){//默认修饰符   带参数
29         System.out.println("method_default_2:"+info);
30     }
31     private void method_private(){
32         System.out.println("method_private");
33     }
34     private void method_private_2(String info){//private  带参数
35         System.out.println("method_private_2:"+info);
36     }

 开始测试如何通过反射机制使用这些方法 

 1 /**
 2      * 如何通过反射机制使用这些方法
 3      * @throws ClassNotFoundException
 4      * @throws NoSuchMethodException
 5      * @throws IllegalAccessException
 6      * @throws InstantiationException
 7      * @throws InvocationTargetException
 8      */
 9     @Test  
10     public void testMethod() throws ClassNotFoundException, NoSuchMethodException,   
11             IllegalAccessException, InstantiationException, InvocationTargetException {  
12         Class clazz = Class.forName("com.xfwl.reflection.Person");  
13       
14         //1、得到clazz 对应的类中有哪些方法,不能获取private方法  
15         Method[] methods =clazz.getMethods();  
16         System.out.println("通过反射机制可以拿到的方法:clazz.getMethods()");  
17         for (Method method : methods){  
18             System.out.println(method.getName());  
19         } 
20         System.out.println("<-------------------------->"); 
21       
22         //2、获取所有的方法(且只获取当着类声明的方法,包括private方法)  
23         Method[] methods2 = clazz.getDeclaredMethods(); 
24         System.out.println("通过反射机制可以拿到的方法:clazz.getDeclaredMethods()");  
25         for (Method method : methods2){  
26             System.out.println(method.getName());  
27         }  
28         System.out.println("<-------------------------->"); 
29         System.out.println("通过反射机制可以拿到指定的方法:clazz.getDeclaredMethod()"); 
30         //3、获取指定的方法  
31         Method  method1= clazz.getDeclaredMethod("method_private");
32         System.out.println("private 无参:"+method1);  
33       
34         Method method2 = clazz.getDeclaredMethod("method_private_2",String.class);//第一个参数是方法名,后面的是方法里的参数  
35         System.out.println("private 有参:"+method2);  
36       
37         Method method3 = clazz.getDeclaredMethod("method_public_2",String.class,int.class,char.class);//第一个参数是方法名,后面的是方法里的参数  
38         System.out.println("public 有参:"+method2);  
39       
40         //4、执行方法!  
41         Object obj = clazz.newInstance();  
42         method3.invoke(obj, "小风微凉", 23,‘M‘);  //执行方法:invoke(类对象)
43     }  

 测试结果: 

通过反射机制可以拿到的方法:clazz.getMethods():不能获取private/protected/default方法 
toString
getName
setName
method_public_2
setAge
method_public
getSex
getAge
setSex
wait
wait
wait
equals
hashCode
getClass
notify
notifyAll
<-------------------------->
通过反射机制可以拿到的方法:clazz.getDeclaredMethods():获取所有修饰权限的方法
toString
getName
setName
method_private_2
method_private
method_public_2
setAge
method_public
method_default
method_default_2
getSex
getAge
setSex
method_protected
method_protected_2
<-------------------------->
通过反射机制可以拿到指定的方法:clazz.getDeclaredMethod()
private 无参:private void com.xfwl.reflection.Person.method_private()
private 有参:private void com.xfwl.reflection.Person.method_private_2(java.lang.String)
public 有参:private void com.xfwl.reflection.Person.method_private_2(java.lang.String)
无参构造!!!
method_public_2
Person{name=‘小风微凉‘, age=23, sex=‘M‘}

 继续分析一下:

JDK中的获取方法

获取方法:默认只能获取public修饰的方法 

1 @CallerSensitive
2     public Method[] getMethods() throws SecurityException {
3         checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
4         return copyMethods(privateGetPublicMethods());
5     }

 获取方法:所有修饰权限的方法都可以获得 

@CallerSensitive
    public Method[] getDeclaredMethods() throws SecurityException {
        checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
        return copyMethods(privateGetDeclaredMethods(false));
    }

 获取方法:获取指定的方法(所有修饰权限) 

 1     /**
 2      * @jls 8.2 Class Members
 3      * @jls 8.4 Method Declarations
 4      * @since JDK1.1
 5      */
 6     @CallerSensitive
 7     public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
 8         throws NoSuchMethodException, SecurityException {
 9         checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
10         Method method = searchMethods(privateGetDeclaredMethods(false), name, parameterTypes);
11         if (method == null) {
12             throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
13         }
14         return method;
15     }

   分析一下上面这个方法:

    String name:方法的名称

       Class<?>... parameterTypes:一个或多个方法参数的类型,注意要一一对应,否则会报错的哦

执行方法:invoke(方法对象,方法实际参数) 

 1 @CallerSensitive
 2     public Object invoke(Object obj, Object... args)
 3         throws IllegalAccessException, IllegalArgumentException,
 4            InvocationTargetException
 5     {
 6         if (!override) {
 7             if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
 8                 Class<?> caller = Reflection.getCallerClass();
 9                 checkAccess(caller, clazz, obj, modifiers);
10             }
11         }
12         MethodAccessor ma = methodAccessor;             // read volatile
13         if (ma == null) {
14             ma = acquireMethodAccessor();
15         }
16         return ma.invoke(obj, args);
17     }

 7、反射机制获取类中的方法:Method: 对应基类或接口中的方法

上面分析了,如何通过反射拿到当前本类里面的各个修饰权限的方法,下面来继续分析一下,如何读取父类或实现的接口中的方法:

现在,给父类添加一些方法,在接口中定义一些方法:

接口中的方法声明: 

1 package com.xfwl.reflection;
2 
3 public interface IHuman {
4 
5     void eat();
6     void eat(String info);
7 }

 Person.java实现接口方法

1     public void eat() {
2         System.out.println("实现接口的方法:eat()无参:");
3     }
4     public void eat(String info) {
5         System.out.println("实现接口的方法:eat()有参:"+info);        
6     }

 父类中的方法定义: 

 1 package com.xfwl.reflection;
 2 
 3 public class Human {
 4     public void play_public(){
 5         System.out.println("public无参:play_public");
 6     }
 7     public void play_public_2(String info){
 8         System.out.println("public有参:play_public2:"+info);
 9     }
10     protected void play_protected(){
11         System.out.println("protected无参:play_protected");
12     }
13     protected void play_protected_2(String info){
14         System.out.println("protected有参:play_protected_2:"+info);
15     }
16     void play_default(){
17         System.out.println("默认修饰符无参:play_default");
18     }
19     void play_default_2(String info){//默认修饰符   带参数
20         System.out.println("默认修饰符有参:play_default_2:"+info);
21     }
22     private void play_private(){
23         System.out.println("private无参:play_private");
24     }
25     private void play_private_2(String info){
26         System.out.println("private有参:play_private_2:"+info);
27     }
28 }

 开始测试:

1、拿到当前Person类反射对象,能否得到接口中的方法 

 1 /**
 2      * 反射机制获取类中的方法:Method: 对应基类或接口中的方法
 3      * @throws ClassNotFoundException 
 4      * @throws SecurityException 
 5      * @throws NoSuchMethodException 
 6      * @throws InstantiationException 
 7      * @throws InvocationTargetException 
 8      * @throws IllegalArgumentException 
 9      * @throws IllegalAccessException 
10      */
11     @Test
12     public void testInterfaceOrSupperClass() throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException{
13          Class clazz = Class.forName("com.xfwl.reflection.Person");
14          //拿到当前Person类反射对象,能否得到接口中的方法     
15          for (Method method : clazz.getMethods()){  
16              System.out.println(method.getName());  
17          }
18         //获取当前类实现的接口中的方法  
19          Method  method1= clazz.getDeclaredMethod("eat");
20          Method  method2= clazz.getDeclaredMethod("eat",String.class);
21          //执行
22          method1.invoke(clazz.newInstance());         
23          method2.invoke(clazz.newInstance(),"eat有参数");  
24     }

 测试结果:(可以拿到实现的接口中的方法并执行) 

toString
getName
setName
eat
eat
method_public_2
setAge
getSex
setSex
getAge
method_public
play_public_2
play_public
wait
wait
wait
equals
hashCode
getClass
notify
notifyAll
无参构造!!!
实现接口的方法:eat()无参:
无参构造!!!
实现接口的方法:eat()有参:eat有参数

 2、拿到当前Person类反射对象,能否获取父类中的方法

通过当前反射对象,拿到父类反射对象 

1 Class clazz = Class.forName("com.xfwl.reflection.Person");
2 Class superClazz = clazz.getSuperclass();  

 

 1 /**
 2      * 反射机制获取类中的方法:Method: 对应基类或接口中的方法
 3      * @throws ClassNotFoundException 
 4      * @throws SecurityException 
 5      * @throws NoSuchMethodException 
 6      * @throws InstantiationException 
 7      * @throws InvocationTargetException 
 8      * @throws IllegalArgumentException 
 9      * @throws IllegalAccessException 
10      */
11     @Test
12     public void testInterfaceOrSupperClass() throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException{
13          Class clazz = Class.forName("com.xfwl.reflection.Person");
14          System.out.println("<------------父类中能够使用的公共权限的方法------------------------>");
15          //拿到当前Person类反射对象,能否获取父类中的方法
16          Class superClazz = clazz.getSuperclass();  
17          for (Method method : superClazz.getMethods()){  
18              System.out.println(method.getName());  
19          }
20          System.out.println("<----------------父类中所有的方法:仅仅父类中的方法-------------------->");
21          //拿到父类中的所有权限修饰符修饰的方法
22          for (Method method : superClazz.getDeclaredMethods()){  
23              System.out.println(method.getName());  
24          }       
25     }

 运行结果: 

<------------父类中能够使用的公共权限的方法------------------------>
play_public
play_public_2
wait
wait
wait
equals
toString
hashCode
getClass
notify
notifyAll
<----------------父类中所有的方法:仅仅父类中的方法-------------------->
play_private_2
play_public
play_public_2
play_private
play_protected
play_default
play_protected_2
play_default_2

 那么可以执行父类中的方法吗? 

1 //是否可以通过子类对象拿到父类中的方法
2          Method  method3= clazz.getDeclaredMethod("play_public");
3          Method  method4= clazz.getDeclaredMethod("play_public_2",String.class);
4          Method  method5= clazz.getDeclaredMethod("play_private");
5          Method  method6= clazz.getDeclaredMethod("play_private_2",String.class);

 上面代码报错,说明不可以,public修饰的方法也拿不到 

1       Method  method7= superClazz.getDeclaredMethod("play_public");
2          Method  method8= superClazz.getDeclaredMethod("play_public_2",String.class);
3          Method  method9= superClazz.getDeclaredMethod("play_private");
4          Method  method10= superClazz.getDeclaredMethod("play_private_2",String.class);

  上面代码正常执行,说明父类的反射对象可以拿到自己的public或private方法 

1  //使用子类的反射对象执行方法
2          method7.invoke(clazz.newInstance());
3          method8.invoke(clazz.newInstance(), "play_public_2有参数");
4          method9.invoke(clazz.newInstance());                       //无法执行,Junit报错
5          method10.invoke(clazz.newInstance(), "play_private_2有参数");//无法执行,Junit报错

  

1 //使用父类的反射对象执行方法
2          method7.invoke(superClazz.newInstance());
3          method8.invoke(superClazz.newInstance(), "play_public_2有参数");
4          method9.invoke(superClazz.newInstance());                       //无法执行,Junit报错
5          method10.invoke(superClazz.newInstance(), "play_private_2有参数");//无法执行,Junit报错

 上面代码执行部分报错,说明通过子类的反射对象和拿到的父类反射对象,也仅仅只能执行public和protected和default默认修饰的方法,不能执行private修饰的方法

7、反射机制获取类中的字段属性:Field字段 

 1    /**
 2      * 默认default修饰
 3      */
 4     String name;
 5     /**
 6      * private修饰
 7      */
 8     private int age;
 9     /**
10      * public修饰
11      */
12     public char sex=‘M‘;
13     /**
14      * protected修饰
15      */
16     protected boolean isBeauty=true;

 开始测试:如何获取 

 1  /**
 2      * 反射机制获取类中的字段属性:Field字段
 3      * @throws ClassNotFoundException 
 4      * @throws SecurityException 
 5      * @throws NoSuchFieldException 
 6      * @throws IllegalAccessException 
 7      * @throws IllegalArgumentException 
 8      */
 9     @Test
10     public void testFiled() throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
11          //拿到反射Class对象
12          Class clazz = Class.forName("com.xfwl.reflection.Person"); 
13          //获取Field的数组,私有字段也能获取
14          Field[] fields = clazz.getDeclaredFields(); 
15          System.out.println("<----遍历拿到字段:开始--------------------->");
16          for (Field field: fields) {  
17                 System.out.println(field.getName());  
18          }
19          System.out.println("<------------获取指定名字的Field以及类型--------------------------->");
20          //获取指定名字的Field(如果是私有的,见下面的4)  
21          Field field1 = clazz.getDeclaredField("name");  
22          System.out.println("获取指定Field名=: " + field1.getName()+",类型:"+field1.getType()); 
23          Field field2 = clazz.getDeclaredField("age");  
24          System.out.println("获取指定Field名=: " + field2.getName()+",类型:"+field2.getType()); 
25          Field field3 = clazz.getDeclaredField("sex");  
26          System.out.println("获取指定Field名=: " + field3.getName()+",类型:"+field3.getType()); 
27          Field field4 = clazz.getDeclaredField("isBeauty");  
28          System.out.println("获取指定Field名=: " + field4.getName()+",类型:"+field4.getType()); 
29          
30          System.out.println("<----------获取指定对象的Field的值 ----------------------------->");
31          Person person = new Person("小风微凉", 12,‘M‘);  
32          //获取指定对象的Field的值  
33          Object val = field1.get(person);  
34          System.out.println("获取指定对象字段‘name‘的Field的值=: " + val);  
35         
36          System.out.println("<----------设置指定对象的Field的值----------------------------->");
37         //设置指定对象的Field的值  
38         field1.set(person, "反射学习A");  
39         System.out.println("设置指定对象字段‘name‘的Field的值=: " + person.name);  
40          
41         System.out.println("<----------若该字段是私有的,需要调用setAccessible(true)方法----------------------------->");
42         //若该字段是私有的,需要调用setAccessible(true)方法  
43         field2 = clazz.getDeclaredField("age");  
44         field2.setAccessible(true);  
45         System.out.println("获取指定私有字段名=: " + field2.getName());  
46     }

 测试结果: 

<----遍历拿到字段:开始--------------------->
name
age
sex
isBeauty
<------------获取指定名字的Field以及类型--------------------------->
获取指定Field名=: name,类型:class java.lang.String
获取指定Field名=: age,类型:int
获取指定Field名=: sex,类型:char
获取指定Field名=: isBeauty,类型:boolean
<----------获取指定对象的Field的值 ----------------------------->
有参构造!!!
获取指定对象字段‘name‘的Field的值=: 小风微凉
<----------设置指定对象的Field的值----------------------------->
设置指定对象字段‘name‘的Field的值=: 反射学习A
<----------若该字段是私有的,需要调用setAccessible(true)方法----------------------------->
获取指定私有字段名=: age

 8、反射机制获取类中的构造器:构造器(Constructor)

Person的构造器

 1 /**
 2      * 无参构造
 3      */
 4     public Person(){
 5         System.out.println("无参构造!!!");
 6     }
 7     /**
 8      * 有参构造
 9      */
10     public Person(String name,int age,char sex){
11         System.out.println("有参构造!!!");
12         this.name=name;
13         this.age=age;
14         this.sex=sex;
15     }

 @Test测试 

 1 /** 
 2      * 构造器:开发用的比较少 
 3      */  
 4     @Test  
 5     public void testConstructor() throws ClassNotFoundException, NoSuchMethodException,  
 6             IllegalAccessException, InvocationTargetException, InstantiationException {  
 7         String className = "com.xfwl.reflection.Person";  
 8         Class<Person> clazz = (Class<Person>) Class.forName(className);  
 9       
10         //1.获取Constructor对象  
11         Constructor<Person>[] constructors =  
12                 (Constructor<Person>[]) Class.forName(className).getConstructors();  
13 
14         System.out.println("<-------------打印所有的构造器---------------------->");
15         for (Constructor<Person> constructor: constructors) {  
16             System.out.println(constructor);  
17         }  
18         System.out.println("<------------------------------------------------>");
19         Constructor<Person> constructor = clazz.getConstructor(String.class, int.class,char.class);  
20         System.out.println("拿到指定的-->" + constructor);  
21       
22         //2.调用构造器的newInstance()方法创建对象  
23         Object obj= constructor.newInstance("changwen", 11,‘M‘);  
24     }

  运行结果: 

<-------------打印所有的构造器---------------------->
public com.xfwl.reflection.Person()
public com.xfwl.reflection.Person(java.lang.String,int,char)
<------------------------------------------------>
拿到指定的-->public com.xfwl.reflection.Person(java.lang.String,int,char)
有参构造!!!

 9、反射机制获取类中的注解:注解(Annotation) 

 ?从 JDK5.0 开始,Java 增加了对元数据(MetaData)的支持,也就是Annotation(注释) 
    ?Annotation其实就是代码里的特殊标记,这些标记可以在编译,类加载, 运行时被读取,并执行相应的处理.通过使用Annotation,程序员可以在不改变原有逻辑的情况下,在源文件中嵌入一些补充信息. 
    ?Annotation 可以像修饰符一样被使用,可用于修饰包,类,构造器, 方法,成员变量, 参数,局部变量的声明,这些信息被保存在Annotation的 “name=value”对中. 
    ?Annotation能被用来为程序元素(类,方法,成员变量等)设置元数据 

基本的 Annotation 

?使用 Annotation时要在其前面增加@符号,并把该Annotation 当成一个修饰符使用.用于修饰它支持的程序元素 
?三个基本的Annotation: 
    –@Override:限定重写父类方法,该注释只能用于方法 
    –@Deprecated:用于表示某个程序元素(类,方法等)已过时 
    –@SuppressWarnings:抑制编译器警告. 

自定义 Annotation 

    ?定义新的 Annotation类型使用@interface关键字 
    ?Annotation 的成员变量在Annotation 定义中以无参数方法的形式来声明.其方法名和返回值定义了该成员的名字和类型. 
    ?可以在定义Annotation的成员变量时为其指定初始值,指定成员变量的初始值可使用default关键字 
    ?没有成员定义的Annotation称为标记;包含成员变量的Annotation称为元数据Annotation 
 1 package com.xfwl.reflection;
 2 
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 
 8 public class Person extends Human implements IHuman {
 9 
10     @Retention(RetentionPolicy.RUNTIME) //运行时检验  
11     @Target(value = {ElementType.METHOD})  //作用在方法上  
12     public @interface AgeValidator {  
13       
14         int min();  
15         int max();  
16     }
17     //......其余部分省略  
18 }

  

 1 /**
 2      * 自定义一个注解:检查年龄范围
 3      * @function  
 4      * @author 小风微凉
 5      * @time  2018-6-3 下午3:56:03
 6      */
 7     @Retention(RetentionPolicy.RUNTIME) //运行时检验  
 8     @Target(value = {ElementType.METHOD})  //作用在方法上  
 9     public @interface AgeValidator { 
10         int min();  
11         int max();  
12     } 

 @Test测试 

 1  /** 
 2      * 通过反射才能获取注解 
 3      */  
 4     @Test  
 5     public void testAnnotation() throws Exception {  
 6         //这样的方式不能使用注解  
 7         /*Person person3 = new Person();  
 8           person3.setAge(10);*/
 9         
10         //拿到反射Class对象
11         String className = "com.xfwl.reflection.Person";  
12         Class clazz = Class.forName(className);  
13         Object obj = clazz.newInstance();  
14         //拿到指定方法
15         Method method = clazz.getDeclaredMethod("setAge",int.class);  
16         int val =40;  
17       
18         //获取注解  
19         Annotation annotation = method.getAnnotation(AgeValidator.class);  
20         if (annotation != null){  
21             if (annotation instanceof AgeValidator){  
22                 AgeValidator ageValidator = (AgeValidator) annotation;  
23       
24                 if (val< ageValidator.min() || val>ageValidator.max()){  
25                     throw new RuntimeException("数值超出范围");  
26                 }  
27             }  
28         }  
29         //执行方法
30         method.invoke(obj, val);  
31         System.out.println(obj);  
32     }

 运行结果:

无参构造!!!
Person{name=‘null‘, age=40, sex=‘M‘}

获取指定注解:

 //获取注解  
        Annotation annotation = method.getAnnotation(AgeValidator.class);  

 获取所有注解:

1  //获取所有注解
2         Annotation[] arr=clazz.getDeclaredAnnotations();

 提取 Annotation信息

?JDK5.0 在 java.lang.reflect包下新增了 AnnotatedElement接口,该接口代表程序中可以接受注释的程序元素
?当一个 Annotation类型被定义为运行时Annotation后,该注释才是运行时可见,当 class文件被载入时保存在 class文件中的 Annotation才会被虚拟机读取
?程序可以调用AnnotationElement对象的如下方法来访问 Annotation信息
–获取 Annotation实例:
?getAnnotation(Class<T> annotationClass)

JDK 的元Annotation

?JDK 的元Annotation 用于修饰其他Annotation 定义
?@Retention:只能用于修饰一个 Annotation定义,用于指定该 Annotation可以保留多长时间,@Rentention包含一个RetentionPolicy类型的成员变量,使用 @Rentention时必须为该 value成员变量指定值:
    –RetentionPolicy.CLASS:编译器将把注释记录在 class文件中.当运行 Java程序时,JVM 不会保留注释.这是默认值
    –RetentionPolicy.RUNTIME:编译器将把注释记录在class文件中. 当运行 Java 程序时, JVM 会保留注释. 程序可以通过反射获取该注释
    –RetentionPolicy.SOURCE:编译器直接丢弃这种策略的注释
?@Target: 用于修饰Annotation 定义,用于指定被修饰的 Annotation能用于修饰哪些程序元素.@Target 也包含一个名为 value的成员变量.
?@Documented:用于指定被该元 Annotation修饰的 Annotation类将被 javadoc工具提取成文档.
?@Inherited:被它修饰的 Annotation将具有继承性.如果某个类使用了被@Inherited 修饰的Annotation, 则其子类将自动具有该注释 

Java反射学习:深入学习Java反射机制

标签:auth   rgs   jdk   person   tde   参考   xtend   它的   max   

原文地址:https://www.cnblogs.com/newwind/p/9129453.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!