java reflect：反射机制

java reflect：反射机制

1. 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();
}
}

}