个人中心
gpt4 book ai didi

JAVA编程不能不知道的反射用法总结

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 33 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章JAVA编程不能不知道的反射用法总结由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

下面对Java反射的基础知识进行说明和总结：

首先定义一个MyBase类，其中有私有字段，也有公有字段。同时也有公有方法和私有方法。MyBase类示例如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.hwdev.demo;
/**
  * 基类示例
  * @author wangming
  */
public class MyBase {
     //公有字段 
     public int version  = 1 ;
     //私有字段
     private String date = "2021-05-18" ;
     //公有方法  
     public void say2(String msg){
     System.out.println( "Hello " + msg);
     }
     //私有方法
     private String getData(){
         return this .date;
     }
} //加入Java开发交流君样：756584822一起吹水聊天

这里再定义一个Hello类，它继承自MyBase类，通过继承主要用于验证一下反射对于父类、子类的反射用法.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.hwdev.demo;
/**
  *
  * @author wangming
  */
public class Hello extends MyBase {
     public String author = "JackWang" ;
     public int version  = 1 ;
     private String company = "kzcloud" ;
     public void say(String msg){
          System.out.println( "Hello " + msg);
     }
     public void setAuthor(String author){
         this .author = author;
     }
     public String getAuthor(){
         return this .author;
     }
     private int getVersion(){
         return this .version;
     }
}

关于Java反射，功能强大的就是可以通过字符串配置来动态从系统中调用方法或者修改其中某个对象的字段值，而Class.forName方法即可以通过传入类全路径字符串名称来获取对应的Class对象，非常的方便。另外通过getField方法和GetMethod方法可以获取指定字段和方法，并动态调用.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package com.hwdev.demo;
import java.lang.reflect.*;
import java.util.Arrays;
/**
  * 反射第一种用法 Class.forName
  * @author wangming
  */
public class ReflectDemo01 {
      public static void Test() {
         try
         {
             //通过字符串全路径类名查找Class
             Class helloC = Class.forName( "com.hwdev.demo.Hello" );
             //获取所有公有的字段数组，私有的无法获取  
             Field [] fields = helloC.getFields();
             //打印字段数组内容//加入Java开发交流君样：756584822一起吹水聊天
             System.out.println(Arrays.toString(fields));
             //[public java.lang.String com.hwdev.demo.Hello.author, public int com.hwdev.demo.Hello.version]
             //实例化
             Object obj = helloC.newInstance();
             //获取特定字段，比遍历Field[]效率更高
             Field f = helloC.getField( "author" );
             if (f != null ){
                 //关闭安全检查，提高效率
                 f.setAccessible( true );
                 //获取字段author内容
                 String author = (String)f.get(obj);
                 System.out.println( "author=" + author);
                 //author=JackWang
             }
             //获取所有公有的方法数组，私有的无法获取
             Method [] methods = helloC.getMethods();
             //打印方法数组内容,子类等方法也可以获取到
             System.out.println(Arrays.toString(methods));
             //本类所有方法
             Method [] methods2 = helloC.getDeclaredMethods();
             //打印方法数组内容
             System.out.println(Arrays.toString(methods2));
             //获取特定方法，第二个参数String.class为say方法的参数类型
             //say(java.lang.String)
             Method m = helloC.getDeclaredMethod( "say" ,String. class );
             if (m != null ){
                 //关闭安全检查，提高效率
                 m.setAccessible( true );
                 //获取字段author内容
                 Object returnValue = m.invoke(obj, new Object[]{ "Java" });
                 //Hello Java
                 if (returnValue!= null ){
                     System.out.println( "returnValue =" + returnValue);   
                 }
             } //加入Java开发交流君样：756584822一起吹水聊天
         } catch (ClassNotFoundException | SecurityException ex){
             ex.printStackTrace();
         }
         catch (Exception ex){
             ex.printStackTrace();
         }
     }   
}

这里需要注意：xxx.getMethods()方法默认情况下，会返回本类、父类、父接口的公有方法，而xxx.getDeclaredMethods()返回本类的 所有方法，包括私有的方法。同理，反射API中其他getXXX和getDeclaredXXX的用法类似.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.hwdev;
import com.hwdev.demo.ReflectDemo01;
/**
  *
  * @author wangming
  */
public class Main {
     /**
      * @param args the command line arguments
      */
     public static void main(String[] args) {
         //反射第一种用法 Class.forName
         ReflectDemo01.Test();
     }   
}

执行程序，输出的结果如下:

[public java.lang.String com.hwdev.demo.Hello.author, public int com.hwdev.demo.Hello.version, public int com.hwdev.demo.MyBase.version] author=JackWang [public void com.hwdev.demo.Hello.say(java.lang.String), public void com.hwdev.demo.Hello.setAuthor(java.lang.String), public java.lang.String com.hwdev.demo.Hello.getAuthor(), public void com.hwdev.demo.MyBase.say2(java.lang.String), public final void java.lang.Object.wait() throws java.lang.InterruptedException, public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException, public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException, public boolean java.lang.Object.equals(java.lang.Object), public java.lang.String java.lang.Object.toString(), public native int java.lang.Object.hashCode(), public final native java.lang.Class java.lang.Object.getClass(), public final native void java.lang.Object.notify(), public final native void java.lang.Object.notifyAll()] [public void com.hwdev.demo.Hello.say(java.lang.String), public void com.hwdev.demo.Hello.setAuthor(java.lang.String), public java.lang.String com.hwdev.demo.Hello.getAuthor(), private int com.hwdev.demo.Hello.getVersion()] Hello Java 。

从输出结果上来看，Field [] fields = helloC.getFields();不但可以获取Hello类的公有字段，还可以获取到父类MyBase的公有字段：com.hwdev.demo.MyBase.version 。

而Method [] methods2 = helloC.getDeclaredMethods();则可以获取本类，即Hello类所有的方法，包括公有的方法和私有的方法。因此，Java反射可以访问类的私有字段和方法，从而暴露内部的信息，这也是Java反射有安全问题的原因.

由于Java方法支持重载，因此同名的方法可以存在多个，即参数不同，因此在用反射调用方法时，需要指定方法的参数类型，这样就可以明确调到的具体是哪个方法签名，如`Method m = helloC.getDeclaredMethod("say",String.class); `调用的是`public void com.hwdev.demo.Hello.say(java.lang.String) `.

除了可以用Class.forName来进行反射外，还可以通过如下方式来获取反射对象:

?
1
2
3
4
5
6
Hello hello = new Hello();
Class helloC = hello.getClass();
Field [] fields = helloC.getFields();
//
Class helloC = Hello. class ;
Field [] fields = helloC.getFields();

下面介绍一下如何用Java反射修改私有字段和调用私有方法的示例:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.hwdev.demo;
import java.lang.reflect.*;
/**
  * 反射访问私有字段和方法
  * @author wangming
  */
public class ReflectDemo02 {
    //加入Java开发交流君样：756584822一起吹水聊天
      public static void Test() {
         try
         {
             //通过已有类查找Class        
             Class helloC = Hello. class ;
             //实例化
             Object obj = helloC.newInstance();
             //获取特定私有字段
             Field f = helloC.getDeclaredField( "company" );
             if (f != null ){
                 //私有必须开启
                 f.setAccessible( true );
                 //设置私有字段值
                 f.set(obj, "newKZ" );
                 //获取字段author内容
                 String fv = (String)f.get(obj);
                 System.out.println( "company=" + fv);
                 //company=newKZ
             }
             //获取私有方法
             Method m = helloC.getDeclaredMethod( "getVersion" , null );
             if (m != null ){
                 //私有必须开启
                 m.setAccessible( true );
                 Object returnValue = m.invoke(obj, null );
                 if (returnValue!= null ){
                     //returnValue =1
                     System.out.println( "returnValue =" + returnValue);   
                 }
             }
         } catch (SecurityException ex){
             ex.printStackTrace();
         }
         catch (Exception ex){
             ex.printStackTrace();
         }
     }   
}

另外，Java反射可以获取注解信息，这个对于ORM框架来讲，用的非常多.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.hwdev.demo;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
  * 注解示例
  * @author wangming
  */
@Retention (RetentionPolicy.RUNTIME)
@Target (ElementType.FIELD)
public @interface ORMAnnotation {
     public String FieldName();
     public String FieldType();
}

其中，@Retention(RetentionPolicy.RUNTIME)表示注解可以在运行时通过反射访问。@Target(ElementType.FIELD) 表示这个注解只能用在字段上面。同理，可以把FIELD改为Type或者Method等.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.hwdev.demo;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
/**
  * 反射或者字段注解
  * @author wangming
  */ //加入Java开发交流君样： 756584822 一起吹水聊天
public class ReflectDemo03 {
      public static void Test() {
         try
         {
             Class helloC = Class.forName( "com.hwdev.demo.HelloAnnotation" );     
             Field[] fields = helloC.getDeclaredFields();
             for (Field f : fields){
                  //关闭安全检查，提高效率
                 f.setAccessible( true );
                 Annotation ann = f.getAnnotation(ORMAnnotation. class );
                 if (ann instanceof ORMAnnotation){
                     ORMAnnotation ormAnn = (ORMAnnotation) ann;
                     System.out.println( "FieldName=" + ormAnn.FieldName());
                     System.out.println( "FieldType=" + ormAnn.FieldType());
                 }
             }         
         } catch (ClassNotFoundException | SecurityException ex){
             ex.printStackTrace();
         }
         catch (Exception ex){
             ex.printStackTrace();
         }
     }   
}

执行此示例，则输出如下:

FieldName=f_author FieldType=varchar(50) FieldName=f_ver FieldType=int 。

再次，介绍一下如何用反射获取方法参数个数和类型，其中包含泛型的信息获取:

  。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package com.hwdev.demo;
import java.util.ArrayList;
import java.util.List;
/**
  * 泛型示例
  * @author wangming
  */
public class GenericCls {
    protected List<String> myList = new ArrayList();
    public GenericCls( int size){     
        for ( int i = 0 ;i<size;i++){
            myList.add( "item" +i);
        }
    }
    public  List<String> getList(){
       return this .myList;
    }
    public String getList( int idx){
       return this .myList.get(idx);
    }
}
package com.hwdev.demo;
import java.lang.reflect.*;
/**
  * 反射获取方法参数
  * @author wangming
  */
public class ReflectDemo05 {
      public static void Test() {
         try
         {
         //加入Java开发交流君样：756584822一起吹水聊天
             Class helloC = Class.forName( "com.hwdev.demo.GenericCls" );
             //构造函数调用
             Object obj = helloC.getConstructor( int . class ).newInstance( 3 );
             Method method = helloC.getMethod( "getList" , int . class );
             Class<?> returnType = method.getReturnType();
             System.out.println( "ReturnType = " + returnType.getName());
             Parameter[] params = method.getParameters();
             for (Parameter p : params){   
                 System.out.println( "ParameterizedType = " + p.getParameterizedType());
                 System.out.println( "getModifiers = " + p.getModifiers());
                 System.out.println( "getName = " + p.getName());
                 System.out.println( "getType = " + p.getType());
             }
            //调用方法
            Object ret =  method.invoke(obj, new Object[]{ 2 });
            System.out.println( "ret = " + ret.toString());
             Method method2 = helloC.getMethod( "getList" , null );
             Type greturnType = method2.getGenericReturnType();
             System.out.println( "getGenericReturnType = " + returnType.getName());
             if (greturnType instanceof ParameterizedType){
                 ParameterizedType type = (ParameterizedType) greturnType;
                 System.out.println( "type = " + type.getTypeName());
                 Type[] typeArguments = type.getActualTypeArguments();
                 for (Type typeArgument : typeArguments){
                     Class typeArgClass = (Class) typeArgument;
                     System.out.println( "typeArgClass = " + typeArgClass);
                 }
             }
         } catch (ClassNotFoundException | SecurityException ex){
             ex.printStackTrace();
         }
         catch (Exception ex){
             ex.printStackTrace();
         }
     }   
}

  。

执行此示例，则输出如下:

R`eturnType = java.lang.String ParameterizedType = int getModifiers = 0 getName = arg0 getType = int ret = item2 getGenericReturnType = java.lang.String type = java.util.List<java.lang.String> typeArgClass = class java.lang.String 。

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我的更多内容！ 。

原文链接：https://blog.csdn.net/wj1314250/article/details/117135271 。

最后此篇关于JAVA编程不能不知道的反射用法总结的文章就讲到这里了,如果你想了解更多关于JAVA编程不能不知道的反射用法总结的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

33 4 0
文章推荐： 解决@Cacheable在同一个类中方法调用不起作用的问题
文章推荐： 2021已过去2022我们继续的说说 2022继续努力的好听的句子
文章推荐： 2022你好抖音很火的说说 2022你好爆火的空间语录
文章推荐： 一篇文章教你使用枚举来实现java单例模式
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com