本文和大家聊聊Java反射。
什么是Java反射(Reflection)?
在程序运行的过程中，能够动态的检索类相关的数据结构信息(包含构造器、字段、方法)，并能对其进行操控的技术。
Java反射能做什么？
- 获取类的构造器
- 获取类的属性(成员变量)
- 获取类的方法
- 调用类的构造器
- 调用类的方法
- 读取或修改类的属性值
Java反射有哪些应用场景？
咱们最常见的，开发人员在IDE(IDEA)中想调用类中某个方法或属性时，在类对象后面一按“.”，IDE就会自动列出它的属性或方法，这里就用到了反射。
一些通用框架中也使用反射，以下以Spring为例：
package com.hys;
/**
* JavaBean
*/
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}
<?xml version="1.0" encoding="UTF-8"?>
<!-- Beans.xml JavaBean 的配置文件 -->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="helloWorld" class="com.hys.HelloWorld">
<property name="message" value="Hello World!"/>
</bean>
</beans>
package com.hys;
/**
* 主应用
*/
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
}
}
执行结果：
Your Message : Hello World!
上面的例子可以看出，Spring框架在Beans.xml中检索到id是“helloWorld”的<bean>，通过<bean>的class属性加载com.hys.HelloWorld类，然后通过反射将<property>的value的内容赋值给com.hys.HelloWorld类的message属性。
下面咱们通过一个一个的小例子，来掌握Java反射如何使用
显示类所有的方法(包含方法的所信息)
package com.hys;
import java.lang.reflect.Method;
public class Main {
public String method1(String s){
return s;
}
private int method2(Object p, int x) throws NullPointerException {
if (p == null)
throw new NullPointerException();
return x;
}
public static void main(String[] args) {
try {
Class cls = Class.forName("com.hys.Main");//
Method methlist[] = cls.getDeclaredMethods();//获得所有方法(包含private)
for (int i = 0; i < methlist.length; i++) {
Method m = methlist[i];
System.out.println("name = " + m.getName());//获取方法名
System.out.println("decl class = " + m.getDeclaringClass());// 获取声明方法的类
Class pvec[] = m.getParameterTypes();//获取方法的参数类型数组
for (int j = 0; j < pvec.length; j++) {
System.out.println("param #" + j + " " + pvec[j]);
}
Class evec[] = m.getExceptionTypes();//获取方法抛出的异常类型数组
for (int j = 0; j < evec.length; j++) {
System.out.println("exc #" + j + " " + evec[j]);
}
System.out.println("return type = " + m.getReturnType());//获取方法返回值类型
}
}
catch (Throwable e) {
System.err.println(e);
}
}
}
执行结果：
name = main
decl class = class com.hys.Main
param #0 class [Ljava.lang.String;
return type = void
name = method2
decl class = class com.hys.Main
param #0 class java.lang.Object
param #1 int
exc #0 class java.lang.NullPointerException
return type = int
name = method1
decl class = class com.hys.Main
param #0 class java.lang.String
return type = class java.lang.String
显示类的所有构建器信息
package com.hys;
import java.lang.reflect.Constructor;
public class Main {
public Main() {
}
protected Main(int i, double d) {
}
public static void main(String[] args) {
try {
Class cls = Class.forName("com.hys.Main");
Constructor ctorlist[] = cls.getDeclaredConstructors();//获取所有构造器(包含private)
for (int i = 0; i < ctorlist.length; i++) {
Constructor ct = ctorlist[i];
System.out.println("name = " + ct.getName()); //获取构造器名称
System.out.println("decl class = " + ct.getDeclaringClass());//获取声明构造器的类
Class pvec[] = ct.getParameterTypes();//获取构造器参数的类型列表
for (int j = 0; j < pvec.length; j++) {
System.out.println("param #" + j + " " + pvec[j]);
}
}
}
catch (Throwable e) {
System.err.println(e);
}
}
}
执行结果：
name = com.hys.Main
decl class = class com.hys.Main
name = com.hys.Main
decl class = class com.hys.Main
param #0 int
param #1 double
显示类的所有字段信息
package com.hys;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class Main {
private double d;
public static final int i = 37;
String s = "testing";
public static void main(String[] args) {
try {
Class cls = Class.forName("com.hys.Main");
Field fieldlist[] = cls.getDeclaredFields();//获取类的所有字段(包含private)
for (int i= 0; i < fieldlist.length; i++) {
Field fld = fieldlist[i];
System.out.println("name = " + fld.getName());//获取属性名
System.out.println("type = " + fld.getType());//获取属性类型
int mod = fld.getModifiers();//获取属性修饰符
System.out.println("modifiers = " + Modifier.toString(mod));
}
}
catch (Throwable e) {
System.err.println(e);
}
}
}
执行结果：
name = d
type = double
modifiers = private
name = i
type = int
modifiers = public static final
name = s
type = class java.lang.String
modifiers =
调用类的方法
package com.hys;
import java.lang.reflect.Method;
public class Main {
public int add(int a, int b)
{
return a + b;
}
public static void main(String[] args) {
try {
Class cls = Class.forName("com.hys.Main");
Object instanceObj = cls.newInstance();//创建类对象实例
Class partypes[] = new Class[2];//为方法创建参数类型数组(add(int,int))
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Method addMethod = cls.getMethod("add", partypes);// 通过方法名称，获取方法对象
Object arglist[] = new Object[2];//为方法创建参数值数组
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retObj = addMethod.invoke(instanceObj, arglist);// 调用add方法
Integer retVal = (Integer)retObj;
System.out.println(retVal.intValue());
}
catch (Throwable e) {
System.err.println(e);
}
}
}
执行结果：
84
修改类的属性值
package com.hys;
import java.lang.reflect.Field;
public class Main {
public double d;
public static void main(String[] args) {
try {
Class cls = Class.forName("com.hys.Main");
Object instanceObj = cls.newInstance();
Field fieldDouble = cls.getField("d");//获得类的属性对象
System.out.println("d = " + ((Main)instanceObj).d);
fieldDouble.setDouble(instanceObj, 12.34);//修改类的属性值
System.out.println("d = " + ((Main)instanceObj).d);
}
catch (Throwable e) {
System.err.println(e);
}
}
}
执行结果：
d = 0.0
d = 12.34
我是青岚之峰，如果读完后感觉有所收获，欢迎点赞加关注
