Java高级特性——反射机制(第三篇)
获取类运行时的结构
通过反射获取运行时类的完整结构
Field、Method、Constructor、Superclass、Interface、Annotation
>实现的全部接口
>所继承的父类
>全部的构造器
>全部的方法
>全部的Field
>注解
......
举例：
package test; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; //获取类的结构 public class Test{ public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, NoSuchMethodException { Class c1 = Class.forName("test.User"); //获得类的名称 System.out.println(c1.getName()); //获得包名+类名 System.out.println(c1.getSimpleName()); //获得类名 //获得类的属性 System.out.println("============================="); Field[] fields = c1.getFields(); //只能找到public属性 for(Field f:fields) { System.out.println("public: "+f); } fields = c1.getDeclaredFields(); //找到全部属性 for(Field f:fields) { System.out.println(f); } //获得指定属性的值 Field f = c1.getDeclaredField("name"); System.out.println(f); //获得所有的方法 System.out.println("============================="); Method[] methods = c1.getMethods(); //只能获取public for(Method m:methods) { System.out.println("public: "+m); } methods = c1.getDeclaredMethods(); //获取所有 for(Method m:methods) { System.out.println(m); } //获取指定的方法 Method getName = c1.getMethod("getName", null); Method setName = c1.getMethod("setName",String.class); System.out.println(getName+"\r\n"+setName); //获取构造方法 System.out.println("============================="); Constructor[] constructor = c1.getConstructors(); for(Constructor c:constructor) { System.out.println("public: "+c); } constructor = c1.getDeclaredConstructors(); for(Constructor c:constructor) { System.out.println(c); } //获取指定构造器 Constructor c = c1.getConstructor(int.class,String.class,int.class); System.out.println(c); } } class User{ private int id; private String name; private int age; public User() { super(); // TODO Auto-generated constructor stub } public User(int id, String name, int age) { super(); this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User [id=" + id + ", name=" + name + ", age=" + age + "]"; } }
结果自行测试！
小结：
1.在实际的开发中，取得类的信息的操作代码并不会经常开发。
2.一定要熟悉java.lang.reflect包的作用、反射机制等。
3.如何取得属性、方法、构造器的名称，修饰符等。
有了Class对象，能做什么？
>创建类的对象，通过Class对象的newInstance()方法.
1.类必须有一个无参构造器。
2.类的构造器的访问权限必须足够。
例子（3-1）：
package test; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; //通过反射动态创建对象 public class Test{ public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException{ Class c1 = Class.forName("test.User"); //构造一个对象 User user = (User)c1.newInstance(); //本质上调用了无参构造器 System.out.println(user); } } class User{ private int id; private String name; private int age; public User() { super(); // TODO Auto-generated constructor stub } public User(int id, String name, int age) { super(); this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User [id=" + id + ", name=" + name + ", age=" + age + "]"; } }
打印结果：
Tip:说明调用无参构造器创建了一个User对象。
思考：难道没有无参构造器就不能创建对象了吗？
答案：可以，只要在操作的时候明确的调用类中的构造器，并将参数传递进去后，就能够实例化。
步骤如下：
1.通过Class类的getDeclaredConstructor(Class ..ParmaterTypes)取得本类的指定形参类型的构造器。
2.向构造器的形参中传递一个数组对象进去，里边包含了构造器中所需的各个参数。
3.通过Constructor的newInstance()方法去实例化对象。
举例（修改3-1的main方法）：
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException{ Class c1 = Class.forName("test.User"); //通过有参构造器构造一个User对象 Constructor constructor = c1.getDeclaredConstructor(int.class,String.class,int.class); User user = (User)constructor.newInstance(1,"hgqin",20); System.out.println(user); }
运行结果：
通过反射调用类中的方法，通过Method完成
1.通过Class类的getDeclaredMethod(String name,Class ...parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
2.之后使用Object invoke(Object obj,Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。
举例（修改3-1的main方法）：
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException{ Class c1 = Class.forName("test.User"); User user = (User)c1.newInstance(); //通过反射获取一个方法 Method method = c1.getDeclaredMethod("setName", String.class); //执行方法(invoke：激活) //(对象，值) method.invoke(user, "Hgqin"); System.out.print(user.getName()); }
执行结果：
通过反射操作属性
setAccessible方法：
举例（修改3-1的main方法）：
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, NoSuchFieldException{ Class c1 = Class.forName("test.User"); User user = (User)c1.newInstance(); //通过反射操作属性 Field name = c1.getDeclaredField("name"); //不能直接操作私有属性，我们需要关闭权限检测 name.setAccessible(true); //关闭安全检测 name.set(user, "hgqin"); System.out.println(user.getName()); }
执行结果：
性能比较
>通过比较普通方法以及反射方法 执行相同的方法所需要的时间，比较性能。大致结果为（普通方法>反射方法（关闭安全检查）>反射方法（不关闭安全检查））
package test; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; //性能分析 public class Test{ public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { test01(); test02(); test03(); } public static void test01() { User user = new User(); Long beginTime = System.currentTimeMillis(); for(int i=0;i<1000000000;i++) { user.getName(); } Long endTime = System.currentTimeMillis(); System.out.println("普通方法执行10亿次需要时间："+(endTime-beginTime)); } public static void test02() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{ User user = new User(); Class c1 = user.getClass(); Method m = c1.getDeclaredMethod("getName", null); Long beginTime = System.currentTimeMillis(); for(int i=0;i<1000000000;i++) { m.invoke(user, null); } Long endTime = System.currentTimeMillis(); System.out.println("反射方式执行10亿次需要时间："+(endTime-beginTime)); } public static void test03() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{ User user = new User(); Class c1 = user.getClass(); Method m = c1.getDeclaredMethod("getName", null); Long beginTime = System.currentTimeMillis(); m.setAccessible(true); for(int i=0;i<1000000000;i++) { m.invoke(user, null); } Long endTime = System.currentTimeMillis(); System.out.println("关闭检测执行10亿次需要时间："+(endTime-beginTime)); } } class User{ private int id; private String name; private int age; public User() { super(); // TODO Auto-generated constructor stub } public User(int id, String name, int age) { super(); this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User [id=" + id + ", name=" + name + ", age=" + age + "]"; } }
打印结果：
反射操作泛型（了解即可）
>Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器Javac使用的，确保数据的安全性和免去强制类型的转换问题，但是一旦编译完成，所有和泛型有关的类型全部擦除。
>为了通过反射操作这些类型，Java新增了ParameterizedType、GenericArrayType、TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。
ParameterizedType：表示一种参数化类型，比如Collection<String>。
CenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型。
WildcardType：代表一种通配符类型的表达式。
举例：
package test; import java.lang.reflect.*; import java.util.*; //通过反射获取泛型 public class Test{ public static void main(String[] args) throws NoSuchMethodException, SecurityException { System.out.println("通过反射获取泛型类型"); //test01 Method method = Test.class.getMethod("test01",Map.class,List.class); Type[] genericParameterTypes = method.getGenericParameterTypes(); for(Type genericParameterType : genericParameterTypes) { System.out.println("#"+genericParameterType); if(genericParameterType instanceof ParameterizedType) { Type[] types = ((ParameterizedType)genericParameterType).getActualTypeArguments(); for(Type type : types) { System.out.println(type); } } } //test02 method = Test.class.getMethod("test02",null); Type genericReturnType = method.getGenericReturnType(); System.out.println("#"+genericReturnType); if(genericReturnType instanceof ParameterizedType) { Type[] types = ((ParameterizedType)genericReturnType).getActualTypeArguments(); for(Type type : types) { System.out.println(type); } } } public void test01(Map<String,User> map,List<User> list) { System.out.println("test01"); } public Map<String,User> test02() { System.out.println("test02"); return null; } } class User{ private int id; private String name; private int age; public User() { super(); // TODO Auto-generated constructor stub } public User(int id, String name, int age) { super(); this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User [id=" + id + ", name=" + name + ", age=" + age + "]"; } }
打印结果：
