AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java 反射经典实例

2017-11-16 1100
版权
举报
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

Cookbook Reflection Java 【转】Java反射经典实例

Java提供了一套机制来动态执行方法和构造方法，以及数组操作等，这套机制就叫——反射。反射机制是如今很多流行框架的实现基础，其中包括Spring、Hibernate等。原理性的问题不是本文的重点，接下来让我们在实例中学习这套精彩的机制.
1. 得到某个对象的属性
  1. public Object getProperty(Object owner, String fieldName) throws Exception {      
  2.     Class ownerClass = owner.getClass();                                          
  3.                                                                                   
  4.     Field field = ownerClass.getField(fieldName);                                 
  5.                                                                                   
  6.     Object property = field.get(owner);                                           
  7.                                                                                   
  8.     return property;                                                              
  9. }                                                                                 

Class ownerClass = owner.getClass()：得到该对象的Class。
Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。
Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。
 
2. 得到某个类的静态属性
  1. public Object getStaticProperty(String className, String fieldName)    
  2.             throws Exception {                                         
  3.     Class ownerClass = Class.forName(className);                       
  4.                                                                        
  5.     Field field = ownerClass.getField(fieldName);                      
  6.                                                                        
  7.     Object property = field.get(ownerClass);                           
  8.                                                                        
  9.     return property;                                                   
  10. }                                                                      
Class ownerClass = Class.forName(className) ：首先得到这个类的Class。
Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。
Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。

3. 执行某对象的方法
  1. public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {   
  2.     Class ownerClass = owner.getClass();   
  3.     Class[] argsClass = new Class[args.length];   
  4.     for (int i = 0, j = args.length; i < j; i++) {   
  5.         argsClass[i] = args[i].getClass();   
  6.     }    
  7.     Method method = ownerClass.getMethod(methodName, argsClass);      
  8.     return method.invoke(owner, args);    
  9. }  
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。
3～6行：配置参数的Class数组，作为寻找Method的条件。
Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。
method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

4. 执行某个类的静态方法
  1. public Object invokeStaticMethod(String className, String methodName,            
  2.             Object[] args) throws Exception {                                    
  3.     Class ownerClass = Class.forName(className);                                 
  4.                                                                                  
  5.     Class[] argsClass = new Class[args.length];                                  
  6.                                                                                  
  7.     for (int i = 0, j = args.length; i < j; i++) {                               
  8.         argsClass[i] = args[i].getClass();                                       
  9.     }                                                                            
  10.                                                                                  
  11.     Method method = ownerClass.getMethod(methodName, argsClass);                 
  12.                                                                                  
  13.     return method.invoke(null, args);                                            
  14. }                                                                                
基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。
 
5. 新建实例
  1. public Object newInstance(String className, Object[] args) throws Exception {    
  2.     Class newoneClass = Class.forName(className);                                
  3.                                                                                  
  4.     Class[] argsClass = new Class[args.length];                                  
  5.                                                                                  
  6.     for (int i = 0, j = args.length; i < j; i++) {                               
  7.         argsClass[i] = args[i].getClass();                                       
  8.     }                                                                            
  9.                                                                                  
  10.     Constructor cons = newoneClass.getConstructor(argsClass);                    
  11.                                                                                  
  12.     return cons.newInstance(args);                                               
  13.                                                                                  
  14. }                                                                                
这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。
Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。
第6～第10行：得到参数的Class数组。
Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。
cons.newInstance(args)：新建实例。

6. 判断是否为某个类的实例
  1. public boolean isInstance(Object obj, Class cls) {        
  2.     return cls.isInstance(obj);                           
  3. }                                                         

7. 得到数组中的某个元素
  1. public Object getByArray(Object array, int index) {       
  2.     return Array.get(array,index);                        
  3. }                                                         

附完整源码：
  1. import java.lang.reflect.Array;   
  2. import java.lang.reflect.Constructor;   
  3. import java.lang.reflect.Field;   
  4. import java.lang.reflect.Method;   
  5.   
  6.   
  7. /**  
  8.  * Java Reflection Cookbook  
  9.  *  
  10.  * @author Michael Lee  
  11.  * @since 2006-8-23  
  12.  * @version 0.1a  
  13.  */  
  14.   
  15. public class Reflection {   
  16.     /**  
  17.      * 得到某个对象的公共属性  
  18.      *  
  19.      * @param owner, fieldName  
  20.      * @return 该属性对象  
  21.      * @throws Exception  
  22.      *  
  23.      */  
  24.     public Object getProperty(Object owner, String fieldName) throws Exception {   
  25.         Class ownerClass = owner.getClass();   
  26.   
  27.         Field field = ownerClass.getField(fieldName);   
  28.   
  29.         Object property = field.get(owner);   
  30.   
  31.         return property;   
  32.     }   
  33.   
  34.     /**  
  35.      * 得到某类的静态公共属性  
  36.      *  
  37.      * @param className   类名  
  38.      * @param fieldName   属性名  
  39.      * @return 该属性对象  
  40.      * @throws Exception  
  41.      */  
  42.     public Object getStaticProperty(String className, String fieldName)   
  43.             throws Exception {   
  44.         Class ownerClass = Class.forName(className);   
  45.   
  46.         Field field = ownerClass.getField(fieldName);   
  47.   
  48.         Object property = field.get(ownerClass);   
  49.   
  50.         return property;   
  51.     }   
  52.   
  53.   
  54.     /**  
  55.      * 执行某对象方法  
  56.      *  
  57.      * @param owner  
  58.      *            对象  
  59.      * @param methodName  
  60.      *            方法名  
  61.      * @param args  
  62.      *            参数  
  63.      * @return 方法返回值  
  64.      * @throws Exception  
  65.      */  
  66.     public Object invokeMethod(Object owner, String methodName, Object[] args)   
  67.             throws Exception {   
  68.   
  69.         Class ownerClass = owner.getClass();   
  70.   
  71.         Class[] argsClass = new Class[args.length];   
  72.   
  73.         for (int i = 0, j = args.length; i < j; i++) {   
  74.             argsClass[i] = args[i].getClass();   
  75.         }   
  76.   
  77.         Method method = ownerClass.getMethod(methodName, argsClass);   
  78.   
  79.         return method.invoke(owner, args);   
  80.     }   
  81.   
  82.   
  83.       /**  
  84.      * 执行某类的静态方法  
  85.      *  
  86.      * @param className  
  87.      *            类名  
  88.      * @param methodName  
  89.      *            方法名  
  90.      * @param args  
  91.      *            参数数组  
  92.      * @return 执行方法返回的结果  
  93.      * @throws Exception  
  94.      */  
  95.     public Object invokeStaticMethod(String className, String methodName,   
  96.             Object[] args) throws Exception {   
  97.         Class ownerClass = Class.forName(className);   
  98.   
  99.         Class[] argsClass = new Class[args.length];   
  100.   
  101.         for (int i = 0, j = args.length; i < j; i++) {   
  102.             argsClass[i] = args[i].getClass();   
  103.         }   
  104.   
  105.         Method method = ownerClass.getMethod(methodName, argsClass);   
  106.   
  107.         return method.invoke(null, args);   
  108.     }   
  109.   
  110.   
  111.   
  112.     /**  
  113.      * 新建实例  
  114.      *  
  115.      * @param className  
  116.      *            类名  
  117.      * @param args  
  118.      *            构造函数的参数  
  119.      * @return 新建的实例  
  120.      * @throws Exception  
  121.      */  
  122.     public Object newInstance(String className, Object[] args) throws Exception {   
  123.         Class newoneClass = Class.forName(className);   
  124.   
  125.         Class[] argsClass = new Class[args.length];   
  126.   
  127.         for (int i = 0, j = args.length; i < j; i++) {   
  128.             argsClass[i] = args[i].getClass();   
  129.         }   
  130.   
  131.         Constructor cons = newoneClass.getConstructor(argsClass);   
  132.   
  133.         return cons.newInstance(args);   
  134.   
  135.     }   
  136.   
  137.   
  138.        
  139.     /**  
  140.      * 是不是某个类的实例  
  141.      * @param obj 实例  
  142.      * @param cls 类  
  143.      * @return 如果 obj 是此类的实例，则返回 true  
  144.      */  
  145.     public boolean isInstance(Object obj, Class cls) {   
  146.         return cls.isInstance(obj);   
  147.     }   
  148.        
  149.     /**  
  150.      * 得到数组中的某个元素  
  151.      * @param array 数组  
  152.      * @param index 索引  
  153.      * @return 返回指定数组对象中索引组件的值  
  154.      */  
  155.     public Object getByArray(Object array, int index) {   
  156.         return Array.get(array,index);   
  157.     }   
  158. }  









本文转自 tony_action 51CTO博客，原文链接：http://blog.51cto.com/tonyaction/51472，如需转载请自行联系原作者
文章标签：
Java
索引
Spring
数据库连接
关键词：
Java实例
Java反射
Java反射实例
余二五
目录
相关文章
潜意识Java
|
3月前
|
存储 Java 计算机视觉
Java二维数组的使用技巧与实例解析
本文详细介绍了Java中二维数组的使用方法
潜意识Java
83 15
潜意识Java
|
3月前
|
缓存 Java 开发者
Java字面量详解：概念、分类与使用实例
本文介绍了Java字面量的概念、分类及应用。
潜意识Java
84 11
三三是该溜子
|
4月前
|
Java 数据库连接 Spring
反射-----浅解析（Java）
在java中，我们可以通过反射机制，知道任何一个类的成员变量（成员属性）和成员方法，也可以堆任何一个对象，调用这个对象的任何属性和方法，更进一步我们还可以修改部分信息和。
三三是该溜子
48 3
智物科技库
|
5月前
|
监控 Java
Java基础——反射
本文介绍了Java反射机制的基本概念和使用方法，包括`Class`类的使用、动态加载类、获取方法和成员变量信息、方法反射操作、以及通过反射了解集合泛型的本质。同时，文章还探讨了动态代理的概念及其应用，通过实例展示了如何利用动态代理实现面向切面编程（AOP），例如为方法执行添加性能监控。
智物科技库
67 5
兴化
|
5月前
|
Java
Java的反射
Java的反射。
兴化
60 2
老皮皮不会弹舌
|
6月前
|
Java
通过Java代码解释成员变量（实例变量）和局部变量的区别
本文通过一个Java示例，详细解释了成员变量（实例变量）和局部变量的区别。成员变量属于类的一部分，每个对象有独立的副本；局部变量则在方法或代码块内部声明，作用范围仅限于此。示例代码展示了如何在类中声明和使用这两种变量。
老皮皮不会弹舌
127 2
廖小凡
|
6月前
|
存储 Java
[Java]反射
本文详细介绍了Java反射机制的基本概念、使用方法及其注意事项。首先解释了反射的定义和类加载过程，接着通过具体示例展示了如何使用反射获取和操作类的构造方法、方法和变量。文章还讨论了反射在类加载、内部类、父类成员访问等方面的特殊行为，并提供了通过反射跳过泛型检查的示例。最后，简要介绍了字面量和符号引用的概念。全文旨在帮助读者深入理解反射机制及其应用场景。
廖小凡
102 0
[Java]反射
LKIDTI数据
|
6月前
|
IDE Java 编译器
java的反射与注解
java的反射与注解
LKIDTI数据
44 0
bug菌
|
6月前
|
安全 Java 测试技术
🌟Java零基础-反射：从入门到精通
【10月更文挑战第4天】本文收录于「滚雪球学Java」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
bug菌
87 2
Codelinghu
|
6月前
|
Java
java的Random类和Arrays.sort类使用实例
java的Random类和Arrays.sort类使用实例
Codelinghu
30 1

热门文章

最新文章

  • 1
    Java版Manus实现来了，Spring AI Alibaba发布开源OpenManus实现
    217
  • 2
    【源码】【Java并发】【ThreadLocal】适合中学者体质的ThreadLocal源码阅读
    219
  • 3
    JAVA接入DeepSeek大模型接口开发---阿里云的百炼模型
    35
  • 4
    Java程序员在AI时代必会的技术：Spring AI
    87
  • 5
    Minecraft配置文件参数说明（JAVA服务器篇）
    30
  • 6
    java常见的集合类有哪些
    27
  • 7
    基于DeepSeek与RAG的智能天气预报系统架构设计与Java实现
    14
  • 8
    GraalVM 24 正式发布阿里巴巴贡献重要特性 —— 支持 Java Agent 插桩
    25
  • 9
    Java机器学习实战：基于DJL框架的手写数字识别全解析
    15
  • 10
    重学Java基础篇—ThreadLocal深度解析与最佳实践
    12
  • 1
    【源码】【Java并发】【ArrayBlockingQueue】适合中学者体质的ArrayBlockingQueue
    32
  • 2
    【Java并发】【ArrayBlockingQueue】适合初学体质的ArrayBlockingQueue入门
    39
  • 3
    Java中实现异步通知的重试机制
    40
  • 4
    智慧班牌源码，采用Java + Spring Boot后端框架，搭配Vue2前端技术，支持SaaS云部署
    47
  • 5
    Playwright多语言生态：跨Python/Java/.NET的统一采集方案
    32
  • 6
    在Java环境下如何进行Redis数据库的操作
    70
  • 7
    java家政系统实现智能派单？
    33
  • 8
    【源码】【Java并发】【ReentrantLock】适合中学者体质的ReentrantLock源码阅读
    53
  • 9
    理解Java引用数据类型：它们都是对象引用
    33
  • 10
    Java 中的 equals 方法：看似简单，实则深藏玄机
    39

    • 相关课程

    更多
  • 「大师课」搞定 Java 开发基础
  • Java Spring Boot 2.6.0开发实战-1024程序员节创造营公益课
  • Java Web开发-Web应用、Tomcat、HTTP请求与响应
  • Java Web开发系列课程 - Spring框架入门
  • Java面向对象开发
  • Java高级开发

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月
    目录