Java反射实战

一、背景

　　最近的项目中需要使用到Java 反射的知识，以前不怎么了解，也基本没怎么用过，抽出一片时间，来具体学习和实战下Java的反射！拿来和大家分享以及记录方便以后学习！

二、反射相关概念解析

1.Class类

　　Class类：Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。

　　如何得到各个类的字节码即Class类呢？

　　　　[1].类名.class:直接通过类.class获得。

　　　　[2].对象.getClass()：通过对象调用其getClass方法获得。　　

　　　　[3].Class.forName("类全路径"):通过类加载器加载获得

　　注：Java中的原始基本类型：boolean, byte, char, short, int, long, float,double和关键词 void同样都有Class类，通过.class可获得它们的类字节码。

2.反射的概念

　　反射就是把Java类中的各种成分映射成相应的Java类，例如一个Java类中用一个Class类的对象表示一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，例如人是一个类，那么人的大脑、双手等也是一个个类。表示Java的Class类显然要提供一系列的方法，来获得其中的变量、方法、构造方法，修饰符、包等信息，这些信息就是用相应的类的实例对象来表示，他们是Field、Method、Contructor、Package等等。

　　一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示。

三、反射实战

测试Bean：Person.java

 1 package com.hafiz.zhang.Bean;
 2
 3 public class Person {
 4     public Integer id;
 5     private String name;
 6
 7     public Person() {
 8     }
 9     public Person(Integer id, String name) {
10         super();
11         this.id = id;
12         this.name = name;
13     }
14     public Integer getId() {
15         return id;
16     }
17     public void setId(Integer id) {
18         this.id = id;
19     }
20     public String getName() {
21         return name;
22     }
23     public void setName(String name) {
24         this.name = name;
25     }
26     @Override
27     public String toString() {
28         return "Person [id=" + id + ", name=" + name + "]";
29     }
30
31     public void sayHello() throws Exception{
32         System.out.println("Hello Reflect!");
33     }
34 }

1.使用反射获取对象所属类的全路径（包括报名和类名）

 1 package com.hafiz.zhang.test;
 2
 3 import com.hafiz.zhang.Bean.Person;
 4
 5 /**
 6  * @author hafiz.Zhang
 7  * @Date 2016年5月18日 下午4:28:35
 8  * @Description 测试通过一个对象获取该对象所属于的类的全路径（包括完整包名和类名）
 9  */
10 public class ReflectTest1 {
11     public static void main(String[] args) {
12         Person person = new Person();
13         System.out.println("ClassName = " + person.getClass().getName());
14     }
15 }

测试结果：

ClassName = com.hafiz.zhang.Bean.Person

2.测试使用反射实例化Class类对象

 1 package com.hafiz.zhang.test;
 2
 3 import com.hafiz.zhang.Bean.Person;
 4
 5 /**
 6  * @author hafiz.Zhang
 7  * @Date 2016年5月18日 下午4:31:36
 8  * @Description 测试获取Class类的三种方式
 9  */
10 public class ReflectTest2 {
11     public static void main(String[] args) {
12         Class<?> obj1 = null;
13         Class<?> obj2 = null;
14         Class<?> obj3 = null;
15         try {
16             //一般尽量要采用这种方式进行实例化Class类对象
17             obj1 = (Class<?>) Class.forName("com.hafiz.zhang.Bean.Person");
18         } catch (ClassNotFoundException e) {
19             e.printStackTrace();
20         }
21         obj2 = new Person().getClass();
22         obj3 = Person.class;
23
24         System.out.println("ClassName:" + obj1.getName());
25         System.out.println("ClassName:" + obj2.getName());
26         System.out.println("ClassName:" + obj3.getName());
27     }
28 }

测试结果：

ClassName:com.hafiz.zhang.Bean.Person
ClassName:com.hafiz.zhang.Bean.Person
ClassName:com.hafiz.zhang.Bean.Person

3.测试通过Class类对象实例化其他类

 1 package com.hafiz.zhang.test;
 2
 3 import com.hafiz.zhang.Bean.Person;
 4
 5 /**
 6  * @author hafiz.Zhang
 7  * @Date 2016年5月18日 下午4:38:15
 8  * @Description 测试通过Class类对象实例化其他类
 9  */
10 public class ReflectTest3 {
11     public static void main(String[] args) {
12         Class<?> clazz = null;
13         try {
14             clazz = Class.forName("com.hafiz.zhang.Bean.Person");
15         } catch (ClassNotFoundException e) {
16             e.printStackTrace();
17         }
18         Person person = null;
19         try {
20             person = (Person) clazz.newInstance();
21         } catch (InstantiationException e) {
22             e.printStackTrace();
23         } catch (IllegalAccessException e) {
24             e.printStackTrace();
25         }
26         if(null != person) {
27             person.setId(1);
28             person.setName("Hafiz.Zhang");
29             System.out.println("person=" + person);
30         }else{
31             System.out.println("实例化对象失败");
32         }
33     }
34 }

测试结果：

person=Person [id=1, name=Hafiz.Zhang]

4.测试通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）

 1 package com.hafiz.zhang.test;
 2
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.InvocationTargetException;
 5
 6 import com.hafiz.zhang.Bean.Person;
 7
 8 /**
 9  * @author hafiz.Zhang
10  * @Date 2016年5月18日 下午4:42:08
11  * @Description 测试通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）
12  */
13 public class ReflectTest4 {
14     public static void main(String[] args) {
15         Class<?> clazz = null;
16         try {
17             clazz = Class.forName("com.hafiz.zhang.Bean.Person");
18         } catch (ClassNotFoundException e) {
19             e.printStackTrace();
20         }
21         Person p1 = null;
22         Person p2 = null;
23         Constructor<?>[] cs = clazz.getConstructors();
24         try {
25             p1 = (Person) cs[0].newInstance();//通过无参构造获得对象
26             p2 = (Person) cs[1].newInstance(1, "Hafiz.Zhang");//通过有参构造获得对象
27         } catch (InstantiationException e) {
28             e.printStackTrace();
29         } catch (IllegalAccessException e) {
30             e.printStackTrace();
31         } catch (IllegalArgumentException e) {
32             e.printStackTrace();
33         } catch (InvocationTargetException e) {
34             e.printStackTrace();
35         }
36         System.out.println("Person1=" + p1);
37         System.out.println("Person2=" + p2);
38     }
39 }

测试结果：

Person1=Person [id=null, name=null]
Person2=Person [id=1, name=Hafiz.Zhang]

5.测试使用反射获取一个类实现的接口

接口Animal.java

 1 package com.hafiz.zhang.Bean;
 2
 3 /**
 4  * @author hafiz.Zhang
 5  * @Date 2016年5月19日 下午6:13:37
 6  * @Description 动物接口
 7  */
 8 public interface Animal {
 9     public abstract void eat();
10     public abstract void sleep();
11 }

接口Skill.java

 1 package com.hafiz.zhang.Bean;
 2
 3 /**
 4  * @author hafiz.Zhang
 5  * @Date 2016年5月19日 下午6:14:06
 6  * @Description 技能接口
 7  */
 8 public interface Skill {
 9     public abstract void sayMiao();
10 }

实现类：Cat.java

 1 package com.hafiz.zhang.Bean;
 2
 3 public class Cat implements Animal, Skill  {
 4     private Integer num;
 5     private String desc;
 6     public Integer getNum() {
 7         return num;
 8     }
 9
10     public void setNum(Integer num) {
11         this.num = num;
12     }
13
14     public String getDesc() {
15         return desc;
16     }
17
18     public void setDesc(String desc) {
19         this.desc = desc;
20     }
21
22     @Override
23     public void eat() {
24         System.out.println("cat eat fish");
25     }
26
27     @Override
28     public void sleep() {
29         System.out.println("cat sleep in the day");
30     }
31
32     @Override
33     public void sayMiao() {
34         System.out.println("cat say miao");
35     }
36
37     public void sayHello(String name){
38         System.out.println("Hello " + name);
39     }
40 }

测试类

 1 package com.hafiz.zhang.test;
 2
 3 /**
 4  * @author hafiz.Zhang
 5  * @Date 2016年5月18日 下午4:51:29
 6  * @Description 测试使用反射获取一个类实现的接口
 7  */
 8 public class ReflectTest5 {
 9     public static void main(String[] args) {
10         Class<?> clazz = null;
11         try {
12             clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
13         } catch (ClassNotFoundException e) {
14             e.printStackTrace();
15         }
16         Class<?>[] interfaces = clazz.getInterfaces();
17         System.out.println("Cat实现的接口有");
18         for(Class<?> cl : interfaces) {
19             System.out.println(cl.getName());
20         }
21     }
22 }

测试结果：

Cat实现的接口有
com.hafiz.zhang.Bean.Animal
com.hafiz.zhang.Bean.Skill

6.测试通过反射取得指定类的父类

 1 package com.hafiz.zhang.test;
 2
 3 /**
 4  * @author hafiz.Zhang
 5  * @Date 2016年5月18日 下午5:03:25
 6  * @Description 测试通过反射取得指定类的父类
 7  */
 8 public class ReflectTest6 {
 9     public static void main(String[] args) {
10         Class<?> clazz = null;
11         try {
12             clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
13         } catch (ClassNotFoundException e) {
14             e.printStackTrace();
15         }
16         Class<?> superClass = clazz.getSuperclass();
17         System.out.println("SuperClass=" + superClass);
18     }
19 }

测试结果：SuperClass=class com.hafiz.zhang.Bean.Person

7.测试通过反射获得其他类中的全部构造函数

 1 package com.hafiz.zhang.test;
 2
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.Modifier;
 5
 6 /**
 7  * @author hafiz.Zhang
 8  * @Date 2016年5月18日 下午5:06:02
 9  * @Description 测试通过反射获得其他类中的全部构造函数
10  */
11 public class ReflectTest7 {
12     public static void main(String[] args) {
13         Class<?> clazz = null;
14         try {
15             clazz = Class.forName("com.hafiz.zhang.Bean.Person");
16         } catch (ClassNotFoundException e) {
17             e.printStackTrace();
18         }
19         Constructor<?>[] cs = clazz.getConstructors();
20         //实现方式1
21         /*for(Constructor<?> item : cs) {
22             System.out.println("构造方法:" + item.getName());
23         }*/
24         //实现方式2
25         for(Constructor<?> item : cs) {
26             System.out.print("构造方法:");
27             System.out.print(Modifier.toString(item.getModifiers()) + " ");
28             System.out.print(item.getName() + "(");
29             Class<?>[] paramterTypes = item.getParameterTypes();
30             for(int i = 0; i < paramterTypes.length; i++) {
31                 System.out.print(paramterTypes[i].getName() + " arg" + i);
32                 if(i < paramterTypes.length-1) {
33                     System.out.print(",");
34                 }
35             }
36             System.out.println(")");
37         }
38     }
39 }

测试结果：

构造方法:public com.hafiz.zhang.Bean.Person()
构造方法:public com.hafiz.zhang.Bean.Person(java.lang.Integer arg0,java.lang.String arg1)

8. 测试通过反射获取类中的所有方法（包括方法包含的异常）

 1 package com.hafiz.zhang.test;
 2
 3 import java.lang.reflect.Method;
 4 import java.lang.reflect.Modifier;
 5
 6 /**
 7  * @author hafiz.Zhang
 8  * @Date 2016年5月18日 下午5:22:51
 9  * @Description 测试通过反射获取类中的所有方法
10  */
11 public class ReflectTest8 {
12     public static void main(String[] args) {
13         Class<?> clazz = null;
14         try {
15             clazz = Class.forName("com.hafiz.zhang.Bean.Person");
16         } catch (ClassNotFoundException e) {
17             e.printStackTrace();
18         }
19         Method[] methods = clazz.getDeclaredMethods();
20         for(Method method : methods) {
21             Class<?> returnType = method.getReturnType();
22             System.out.print(Modifier.toString(method.getModifiers()) + " ");
23             System.out.print(returnType.getName() + " " + method.getName() + "(");
24             Class<?>[] paras = method.getParameterTypes();
25             for(int i = 0 ; i < paras.length ; i++) {
26                 System.out.print(paras[i].getName() + " arg" + i);
27                 if(i < paras.length - 1) {
28                     System.out.print(",");
29                 }
30             }
31             Class<?>[] exces = method.getExceptionTypes();
32             if(exces.length > 0) {
33                 System.out.print(") throws ");
34                 for(int j = 0; j < exces.length; j++) {
35                     System.out.print(exces[j].getName());
36                     if(j < exces.length - 1) {
37                         System.out.print(", ");
38                     }
39                 }
40             }else{
41                 System.out.print(")");
42             }
43             System.out.println();
44         }
45     }
46 }

测试结果：

public java.lang.String toString()
public java.lang.String getName()
public void setName(java.lang.String arg0)
public java.lang.Integer getId()
public void sayHello() throws java.lang.Exception
public void setId(java.lang.Integer arg0)

9.测试通过反射获取类中所有的属性

 1 package com.hafiz.zhang.test;
 2
 3 import java.lang.reflect.Field;
 4 import java.lang.reflect.Modifier;
 5
 6 /**
 7  * @author hafiz.Zhang
 8  * @Date 2016年5月18日 下午5:38:09
 9  * @Description 测试通过反射获取类中所有的属性
10  */
11 public class ReflectTest9 {
12     public static void main(String[] args) {
13         Class<?> clazz = null;
14         try {
15             clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
16         } catch (ClassNotFoundException e) {
17             e.printStackTrace();
18         }
19         Field[] fields = clazz.getDeclaredFields();
20         System.out.println("=========通过反射获取指定类中所有的属性=========");
21         for(Field field : fields) {
22             System.out.println(Modifier.toString(field.getModifiers()) + " " + field.getType().getName() + " " + field.getName());
23         }
24         System.out.println("=========通过反射获取指定类实现的接口或者父类中所有的属性=========");
25         Field[] fields2 = clazz.getSuperclass().getDeclaredFields();
26         for(Field item : fields2) {
27             System.out.println(Modifier.toString(item.getModifiers()) + " " + item.getType() + " " + item.getName());
28         }
29     }
30 }

测试结果：

=========通过反射获取指定类中所有的属性=========
private java.lang.Integer num
private java.lang.String desc
=========通过反射获取指定类实现的接口或者父类中所有的属性=========
public class java.lang.Integer id
private class java.lang.String name

10.测试使用反射调用指定类的方法

 1 package com.hafiz.zhang.test;
 2
 3 import java.lang.reflect.InvocationTargetException;
 4 import java.lang.reflect.Method;
 5
 6 /**
 7  * @author hafiz.Zhang
 8  * @Date 2016年5月19日 下午3:22:33
 9  * @Description 测试使用反射调用指定类的方法
10  */
11 public class ReflectTest10 {
12     public static void main(String[] args) {
13         Class<?> clazz = null;
14         try {
15             clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
16         } catch (ClassNotFoundException e) {
17             e.printStackTrace();
18         }
19         try {
20             //调用Cat类中的eat无参方法
21             Method method = clazz.getMethod("eat");
22             method.invoke(clazz.newInstance());
23             //调用Cat类中的sayHello有参方法
24             Method method2 = clazz.getDeclaredMethod("sayHello", String.class);
25             method2.invoke(clazz.newInstance(), "Hafiz.Zhang");
26         } catch (NoSuchMethodException e) {
27             e.printStackTrace();
28         } catch (SecurityException e) {
29             e.printStackTrace();
30         } catch (IllegalAccessException e) {
31             e.printStackTrace();
32         } catch (IllegalArgumentException e) {
33             e.printStackTrace();
34         } catch (InvocationTargetException e) {
35             e.printStackTrace();
36         } catch (InstantiationException e) {
37             e.printStackTrace();
38         }
39     }
40 }

测试结果：

cat eat fish
Hello Hafiz.Zhang

11.测试通过反射调用其他类中的setter和getter方法

 1 package com.hafiz.zhang.test;
 2
 3 import java.lang.reflect.InvocationTargetException;
 4 import java.lang.reflect.Method;
 5
 6 /**
 7  * @author hafiz.Zhang
 8  * @Date 2016年5月19日 下午3:29:34
 9  * @Description 测试通过反射调用其他类中的setter和getter方法
10  */
11 public class ReflectTest11 {
12     public static void main(String[] args) {
13         Class<?> clazz = null;
14         Object obj = null;
15         try {
16             clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
17             obj = clazz.newInstance();
18         } catch (ClassNotFoundException e) {
19             e.printStackTrace();
20         } catch (InstantiationException e) {
21             e.printStackTrace();
22         } catch (IllegalAccessException e) {
23             e.printStackTrace();
24         }
25         getter(obj,"Desc");
26         setter(obj,"Desc","测试调用set方法",String.class);
27         getter(obj,"Desc");
28     }
29
30     private static void getter(Object obj, String name) {
31         try {
32             Method method = obj.getClass().getMethod("get"+name);
33             System.out.println(name + ":" + method.invoke(obj));
34         } catch (NoSuchMethodException e) {
35             e.printStackTrace();
36         } catch (SecurityException e) {
37             e.printStackTrace();
38         } catch (IllegalAccessException e) {
39             e.printStackTrace();
40         } catch (IllegalArgumentException e) {
41             e.printStackTrace();
42         } catch (InvocationTargetException e) {
43             e.printStackTrace();
44         }
45     }
46
47     private static void setter(Object obj, String name, String desc, Class<?> type) {
48         try {
49             Method method = obj.getClass().getMethod("set" + name, type);
50             method.invoke(obj, desc);
51         } catch (NoSuchMethodException e) {
52             e.printStackTrace();
53         } catch (SecurityException e) {
54             e.printStackTrace();
55         } catch (IllegalAccessException e) {
56             e.printStackTrace();
57         } catch (IllegalArgumentException e) {
58             e.printStackTrace();
59         } catch (InvocationTargetException e) {
60             e.printStackTrace();
61         }
62     }
63 }

测试结果：

Desc:null
Desc:测试调用set方法

12.测试通过反射操作属性

 1 package com.hafiz.zhang.test;
 2
 3 import java.lang.reflect.Field;
 4
 5 /**
 6  * @author hafiz.Zhang
 7  * @Date 2016年5月19日 下午3:41:59
 8  * @Description 测试通过反射操作属性
 9  */
10 public class ReflectTest12 {
11     public static void main(String[] args) {
12         Class<?> clazz = null;
13         Object obj = null;
14         try {
15             clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
16             obj = clazz.newInstance();
17             Field field = clazz.getDeclaredField("desc");
18             //若要设置private属性，需要设置
19             field.setAccessible(true);//设置成员变量可访问，包括private成员变量（暴力反射）,private成员通过这步操作才能被访问
20             field.set(obj, "this is test demo");
21             System.out.println("Desc=" + field.get(obj));
22         } catch (ClassNotFoundException e) {
23             e.printStackTrace();
24         } catch (InstantiationException e) {
25             e.printStackTrace();
26         } catch (IllegalAccessException e) {
27             e.printStackTrace();
28         } catch (NoSuchFieldException e) {
29             e.printStackTrace();
30         } catch (SecurityException e) {
31             e.printStackTrace();
32         }
33
34     }
35 }

测试结果：Desc=this is test demo

13.测试通过反射进行数组操作

 1 package com.hafiz.zhang.test;
 2
 3 import java.lang.reflect.Array;
 4
 5 /**
 6  * @author hafiz.Zhang
 7  * @Date 2016年5月19日 下午4:52:21
 8  * @Description 测试通过反射进行数组操作
 9  *
10  */
11 public class ReflectTest13 {
12     public static void main(String[] args) {
13         Integer[] array = {1,2,3,4,5,6};
14         Class<?> clazz = array.getClass().getComponentType();
15         System.out.println("数组类型：" + clazz.getName());
16         System.out.println("数组长度：" + Array.getLength(array));
17         System.out.println("数组第一个元素：" + Array.get(array, 0));
18         Array.set(array, 0, 8);
19         System.out.println("修改之后数组第一个元素：" + Array.get(array, 0));
20         System.out.println("=============反射修改数组长度=================");
21         Integer[] arr2 = (Integer[])changeLength(array, 10);
22         print(arr2);
23     }
24     private static void print(Object obj) {
25         Class<?> clazz = obj.getClass();
26         if(!clazz.isArray()) {
27             return;
28         }
29         System.out.println("数组长度为：" + Array.getLength(obj));
30         for(int i = 0; i < Array.getLength(obj); i++){
31             System.out.print(Array.get(obj, i) + " ");
32         }
33     }
34     public static Object changeLength(Object obj, Integer length){
35         Class<?> clazz = obj.getClass().getComponentType();
36         Object newArr = Array.newInstance(clazz, length);
37         Integer len = Array.getLength(obj);
38         System.arraycopy(obj, 0, newArr, 0, len);
39         return newArr;
40     }
41 }

测试结果：

数组类型：java.lang.Integer
数组长度：6
数组第一个元素：1
修改之后数组第一个元素：8
=============反射修改数组长度=================
数组长度为：10
8 2 3 4 5 6 null null null null

时间： 2024-11-18 14:56:55

Java反射实战的相关文章

java反射练习

这个java反射的练习,主要包含了反射的构造函数,属性,方法的调用,main方法的调用,以及一个简单的实战练习从文件中读取,并操作类.(用的是junit测试的,没有使用main方法的调用方式) Person类: package cn.wwh.www.reflect; /** *类的作用:纯粹是一个实体类包含属性和方法的测试类 * * *@author 一叶扁舟 *@version 1.0 *@创建时间: 2014-7-20   上午10:18:59 */ public class Person

Java反射学习总结

广州疯狂软件教育Java培训,iOS培训分享Class类是Reflection API中核心的类,他位于java.lang.Class列出一些常用的方法.- getName() : 获得类的完整名字- getFields() : 获得类的public类型的属性- getDeclaredFields() : 获得类的所有属性- getMethods() : 获得类的public类型的方法- getDeclaredMethods() : 获得类的所有方法- getMethod(String name

粗浅看 java反射机制

什么是  Java 反射是 Java 被视为动态(或准动态)语言的一个关键性质.这个机制允许程序在运 行时透过 Reflection APIs 取得任何一个已知名称的class 的内部信息,包括其 modifiers( 诸如 public, static 等 ).superclass (例如 Object). 实现之 interfaces(例如 Cloneable),也包括 fields 和 methods 的所有信息,并可于运行时改变 fields 内容或唤起 methods. Java 反射

Java反射

1. 介绍 反射是一种能够在程序运行时动态访问.修改某个类中任意属性和方法的机制. 具体:对于任意一个类,都能够知道这个类的所有属性和方法对于任意一个对象,都能够调用它的任意一个方法和属性 在运行时,当加载完类之后,JVM在堆内存中会自动产生一个Class类型的对象,这个对象包含了完整的类的结构信息 这个Class对象就像一面镜子,透过这个镜子看到类的结构 那么,如何得到这个Class对象呢?以下可否 Class c = new Class(); 答案是不行的,因为Class的构造函数定义为私有

Java 反射详解

反射反射,程序员的快乐,今天你快乐了吗?如果你不快乐,没关系,接下来让你快乐起来! 一.什么是反射? 通过百度百科我们可以知道,Java反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意方法和属性:并且能改变它的属性.而这也是Java被视为动态(或准动态,为啥要说是准动态,因为一般而言的动态语言定义是程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言.从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C

java反射机制（一）—— 利用反射机制实例化对象

一.Java有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载.探知.使用编译期间完全未知的classes.换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体.或对其fields设值.或唤起其methods.(度娘文库是这么说的) 二.这篇文章主要介绍一下通过反射机制去实例化一个类的对象,然后调用其方法.本文主要介绍两种方式,第一种就是通过构造函数来实例化,第二种就是通过Cl

java 反射 详解

本文来自:blog.csdn.net/ljphhj JAVA反射机制:   通俗地说,反射机制就是可以把一个类,类的成员(函数,属性),当成一个对象来操作,希望读者能理解,也就是说,类,类的成员,我们在运行的时候还可以动态地去操作他们. 理论的东东太多也没用,下面我们看看实践 Demo - Demo: package cn.lee.demo; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import

【java】java反射机制，动态获取对象的属性和对应的参数值，并属性按照字典序排序，Field.setAccessible()方法的说明【可用于微信支付 签名生成】

方法1:通过get()方法获取属性值 package com.sxd.test.controller; public class FirstCa{ private Integer num; private String name; private Boolean flag; public Integer getNum() { return num; } public void setNum(Integer num) { this.num = num; } public String getNam

java 反射类的理解与应用

本文主要解析的类是: ClassLodaer,Class,Field,Method,Constructor. 本文的目标很简单,只是对这些常用的反射类进行简单解释.对这些类中常用方法进行介绍. JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制.Java反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类:在运行时构造任意一个类的对象:在