java reflect:反射机制
1. Class 类型:
java reflect的基础是Class 类,Class 类代表的是 java 源文件通过编译后得到的字节码;
获得 Class 类型 的几种方法:
1. 类名.class
2. 对象名.getClass()
3. Class.forName("类路径")
2. constructor reflect: 构造函数的反射
package cn.wzb.reflect;
import java.lang.reflect.Constructor;
import java.util.HashMap;
/**
* Created by zhongbo.wzb on 16/7/23.
*/
public class ConstructorReflect {
public static void main(String[] args) {
try {
//获取Integer的Class
Class<?> clazz = Class.forName("java.lang.Integer");
System.out.println(clazz.getClass());
//使用类中参数为String类型的构造器
Constructor<?> constructor = clazz.getConstructor(String.class);
//使用构造器创建一个实例对象
Object obj = constructor.newInstance("10");
//打印结果
System.out.println(obj);
HashMap<String, Integer> a = new HashMap<String, Integer>();
clazz = a.getClass();
System.out.println(clazz.getName());
System.out.println(clazz.getCanonicalName());
System.out.println(clazz.toString());
System.out.println(clazz.toGenericString());
} catch (Exception e) {
e.printStackTrace();
}
}
}
3. field reflect: 成员变量的反射
package cn.wzb.reflect;
import java.lang.reflect.Field;
/**
* Created by zhongbo.wzb on 16/7/23.
*/
public class FieldReflect {
public static void main(String[] args) {
try {
//创建一个Person实例对象
Person person = new FieldReflect().new Person();
//取得Class
// Class<?> clazz = person.getClass();
Class<?> clazz = Person.class;
/******** 通过反射访问 public 权限的属性变量 ********/
//取得字段的属性名
Field age = clazz.getDeclaredField("age");
//设置该属性的值
age.set(person, 22);
/******* 通过反射访问 protected 权限的属性变量 *******/
Field mail = clazz.getDeclaredField("mail");
mail.set(person, "wzb12008@sina.com");
/******** 通过反射访问 private 权限的属性变量 ********/
Field name = clazz.getDeclaredField("name");
//private修饰的变量不能直接访问,
//如需访问必须要将setAccessible的值设置成true,
//也就是强制访问,或者说是暴力访问
name.setAccessible(true);
name.set(person, "zhongbo");
System.out.println(person);
Field[] fields = clazz.getFields();
for (Field f : fields) {
System.out.println(f.getName());
}
System.out.println();
fields = clazz.getDeclaredFields();
for (Field f : fields) {
System.out.println(f.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
//内部类
public class Person {
public int age;
private String name;
protected String mail;
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getMail() {
return mail;
}
public void setMail(String mail) {
this.mail = mail;
}
@Override
public String toString() {
return "Name is:" + name + ",\t Age is:" + age + ",\t Mail is:" + mail;
}
}
}
4. method reflect: 方法的反射
package cn.wzb.reflect;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
/**
* Created by zhongbo.wzb on 16/7/23.
*/
public class MethodReflect {
public static void main(String[] args){
try {
//取得Class
Class<?> clazz = Class.forName("cn.wzb.reflect.MethodReflect");
MethodReflect instance = new MethodReflect();
clazz = instance.getClass();
clazz = MethodReflect.class;
//取得方法
Method m = clazz.getDeclaredMethod("print", String.class);
//调用该方法
m.invoke(clazz.newInstance(), "fancy");
Method[] methods = clazz.getMethods();
for (Method method : methods) {
System.out.print(Modifier.toString(method.getModifiers()));
System.out.print(" ");
System.out.print(method.getReturnType().getName());
System.out.print(" ");
System.out.println(method.getName());
System.out.println(method.getParameterCount());
for (Class<?> T: method.getParameterTypes()) {
System.out.println(T.getName());
}
for (Type T: method.getGenericParameterTypes()) {
System.out.println(T.getTypeName());
}
Annotation[] annotations = method.getDeclaredAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation.getClass().getName());
}
System.out.println();
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void print(int arg){
System.out.println("Arg is int, value is " + arg);
}
public void print(String arg){
System.out.println("Arg is String, value is " + arg);
}
}
5. generic reflect:泛型类型的反射(运行时取消泛型)
package cn.wzb.reflect;
import java.lang.reflect.Method;
import java.util.ArrayList;
/**
* Created by zhongbo.wzb on 16/7/23.
*/
/**
* TOPIC:ArrayList<Integer> list = new ArrayList<Integer>();
* 在这个泛型为Integer的ArrayList中存放一个String类型的对象。
*/
public class GenericReflect {
public static void main(String[] args) {
/**
* 泛型的类型检查只存在编译期间,运行期间并不存在泛型类型,可以用反射来实现题设要求
*/
try {
ArrayList<Integer> list = new ArrayList<Integer>();
ArrayList<String> list1 = new ArrayList<String>();
Method add = ArrayList.class.getDeclaredMethod("add", Object.class);
add.invoke(list, "fancy");
System.out.println(list.get(0));
System.out.println(list.getClass().getName());
System.out.println(list1.getClass().getName());
System.out.println(list.getClass().equals(list1.getClass()));
System.out.println(list instanceof ArrayList<?>);
System.out.println(list1 instanceof ArrayList<?>);
} catch (Exception e) {
e.printStackTrace();
}
}
}