Java 反射机制初步了解-爱代码爱编程
反射机制
指的是可以于运行时加载、探知、使用编译期间完全未知的类。
程序在运行状态中,可以动态加载一个只有名称的类,对于任意一个 已加载的类,都能够知道这个类的所有属性和方法;对于任意一个对 象,都能够调用它的任意一个方法和属性:
Class c = Class.forName("Path")
加载完类之后,在堆内存中,就产生了一个Class类型的对象(一个类只有一个Class 对象),这个对象就包含了完整的类的结构信息,我们可以通过这个对象看到类的结构,这个对象就像一面镜子。所以,我们形象的称之为:反射。
常见用法:
• 动态构造类的反射对象
/*
测试各种类型对应的java.lang.Class对象的获取方式
*/
@SuppressWarnings("all")
public class Demo01 {
public static void main(String[] args) {
String path = "SAMPLE.反射机制.User";
try {
//一个类被加载后,JVM会创建一个对应该类的Class对象,类的整个结构信息会放到对应的Class对象中。
//这个Class对象就像一面镜子一样,通过这面镜子我可以看到对应类的全部信息。
Class clazz = Class.forName(path);
//一个类只对应一个Class对象,都具有相同的哈希码
Class clazz2 = Class.forName(path);
System.out.println(clazz.hashCode());
System.out.println(clazz2.hashCode());
//相同类型为同一个对象
Class strClazz = String.class;
Class strClazz2 = "I'm msg".getClass();
System.out.println(strClazz==strClazz2);
int[] arr01 = new int[10];
int[][] arr02 = new int[30][3];
double[] arr04 = new double[10];
System.out.println(arr01.getClass().hashCode());
System.out.println(arr02.getClass().hashCode());
System.out.println(arr04.getClass().hashCode());
} catch (Exception e) {
e.printStackTrace();
}
}
}
• 动态获取类的信息(属性、方法、构造器)
import java.lang.reflect.*;
/*
利用用反射获取类的信息(类的名字、属性、方法、构造器等)
*/
public class Demo02 {
public static void main(String[] args) {
String path = "SAMPLE.反射机制.User";
try {
Class clazz = Class.forName(path);
//获取类的名字
System.out.println(clazz.getName());//获得包名+类名:com.bjsxt.test.bean.User
System.out.println(clazz.getSimpleName()); //获的类名:User
//获取属性信息
Field[] fields = clazz.getFields(); //只能获得public的field
fields = clazz.getDeclaredFields();//获得所有的field
Field f = clazz.getDeclaredField("uname");//按命名获取属性
//获取方法信息
Method[] methods = clazz.getDeclaredMethods();
Method m01 = clazz.getDeclaredMethod("getUname", null);//按命名、形参获取方法
Method m02 = clazz.getDeclaredMethod("setUname", String.class);//如果方法有参,则必须传递参数类型对应的class对象
//获得构造器信息
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);//按构造方法的形参获取
} catch (Exception e) {
e.printStackTrace();
}
}
}
• 动态调用类的任意方法、构造器、属性
import java.lang.reflect.*;
import SAMPLE.反射机制.User;
/*
通过反射对对象进行动态的操作
*/
public class Demo03 {
public static void main(String[] args) {
String path = "SAMPLE.反射机制.User";
try {
Class<User> clazz = (Class<User>) Class.forName(path);
//通过反射API调用构造方法,构造对象
User u = clazz.newInstance();// 其实是调用了User的无参构造方法
Constructor<User> c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
User u2 = c.newInstance(1001,18,"name1");
System.out.println(u2.getUname());
//通过反射API调用普通方法
User u3 = clazz.newInstance();
Method method = clazz.getDeclaredMethod("setUname", String.class);
method.invoke(u3, "name3");// u3.setUname("name3");
System.out.println(u3.getUname());
//通过反射API操作属性
User u4 = clazz.newInstance();
Field f = clazz.getDeclaredField("uname");
f.setAccessible(true); // 这个属性不需要做安全检查了,可以直接访问
f.set(u4, "name4"); // 通过反射直接写属性
System.out.println(u4.getUname()); //通过反射直接读属性的值
System.out.println(f.get(u4));
} catch (Exception e) {
e.printStackTrace();
}
}
}
• 获取泛型信息
package SAMPLE.反射机制;
import java.lang.reflect.*;
import java.util.*;
/*
通过反射获取泛型信息
*/
public class Demo04 {
public void test1(Map<String,User> map,List<User> list){
System.out.println("Demo04.test1()");
}
public Map<Integer,User> test2(){
System.out.println("Demo04.test2()");
return null;
}
public static void main(String[] args) {
try {
//获得指定方法参数泛型信息
Method m = Demo04.class.getMethod("test1", Map.class,List.class);
Type[] t = m.getGenericParameterTypes();
for (Type paramType : t) {
System.out.println("方法的形参为:"+paramType);
if(paramType instanceof ParameterizedType){
Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();
System.out.println("形参的泛型为:");
for (Type genericType : genericTypes) {
System.out.println(genericType);
}
}
}
System.out.println("----------------");
//获得指定方法返回值的泛型信息
Method m2 = Demo04.class.getMethod("test2", null);
Type returnType = m2.getGenericReturnType();
System.out.println("返回值类型为:"+returnType);
if(returnType instanceof ParameterizedType){
Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();
System.out.println("返回值的泛型为:");
for (Type genericType : genericTypes) {
System.out.println(genericType);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
• 获取注解
import java.lang.annotation.Annotation;
/*
通过反射获取注解信息
*/
public class Demo05 {
public static void main(String[] args) {
try {
Class clazz = Class.forName("");
//获得类的所有有效注解
Annotation[] annotations=clazz.getAnnotations();
for (Annotation a : annotations) {
System.out.println(a);
}
/*获得类的指定的注解
注解名称 annotation = (注解名称) clazz.getAnnotation(注解名称.class);
*/
/*获得类的属性的注解
Field f = clazz.getDeclaredField("studentName");
注解名称 annotation = f.getAnnotation(注解名称.class);
*/
} catch (Exception e) {
e.printStackTrace();
}
}
}
• 反射效率的比较
import java.lang.reflect.Method;
/*
通过跳过安全检查,提高反射效率
三种执行方法的效率差异比较
*/
public class Demo06 {
public static void test01(){
User u = new User();
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000L; i++) {
u.getUname();
}
long endTime = System.currentTimeMillis();
System.out.println("普通方法调用,执行10亿次,耗时:"+(endTime-startTime)+"ms");
}
public static void test02() throws Exception{//需执行安全检查
User u = new User();
Class clazz = u.getClass();
Method m = clazz.getDeclaredMethod("getUname", null);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000L; i++) {
m.invoke(u, null);
}
long endTime = System.currentTimeMillis();
System.out.println("反射动态方法调用,执行10亿次,耗时:"+(endTime-startTime)+"ms");
}
public static void test03() throws Exception{//不需要执行访问安全检查
User u = new User();
Class clazz = u.getClass();
Method m = clazz.getDeclaredMethod("getUname", null);
m.setAccessible(true);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000L; i++) {
m.invoke(u, null);
}
long endTime = System.currentTimeMillis();
System.out.println("反射动态方法调用,跳过安全检查,执行10亿次,耗时:"+(endTime-startTime)+"ms");
}
public static void main(String[] args) throws Exception {
test01();// 2s
test02();// 60s
test03();// 15s
}
}