Field类详解

1. //AccessibleObject 类是 Field、Method 和 Constructor 对象的基类。  
2. public class AccessibleObject implements AnnotatedElement {  
3.     /*  
4.      * 1、实现了AnnotatedElement对注解支持的相关方法  
5.      * 2、提供访问控制   
6.      /  
7.     void setAccessible(boolean flag)   
8.     设置该对象(Field,Constructor,Method)是否可访问  
9.     boolean isAccessible()   
10.     该对象是否可访问  
11.     void setAccessible(AccessibleObject[] array, boolean flag)   
12.     设置这一组对象(Field,Constructor,Method)是否可访问  
13.   
14. }  
15. public interface Member{  
16.    public static final int PUBLIC = 0; //标识类或接口的所有已声明成员的集合。  
17.    public static final int DECLARED = 1; //标识类或接口的所有公共成员（包括继承成员）的集合。  
18.      
19.    public Class<?> getDeclaringClass();// 所在类  
20.    public String getName(); //返回此 Member 表示的底层成员或构造方法的简单名称。  
21.    public int getModifiers(); //作为整数返回由此 Member 所表示的成员或构造方法的 Java 语言修饰符。  
22.    public boolean isSynthetic(); //如果此成员是编译器引入的，则返回 true；否则，返回 false。  
23.   
24. }  
25. public final class Field extends AccessibleObject implements Member{  
26.    
27.    // 1.字段的设值和取值 ,对于静态属性，obj传null  
28.     set(Object obj, Object value)   
29.     setXX(Object obj, Object value) ,比如setInt,setBoolean  
30.     Object get(Object obj)  
31.     getXX(Object obj) ,比如getInt,getBoolean  
32.       
33.       
34.     // 2.字段上注解的获取  
35.     getDeclaredAnnotations()   
36.     getAnnotation(Class<T> annotationClass);   
37.       
38.     // 3.字段类型  
39.       Type getGenericType();  
40.       Class<?> getType();  
41.     // 4.字段修饰符  
42.       int modifer=field.getModifiers();  
43.       String modify = Modifier.toString(modifiers);  
44.     // 5.字段名称  
45.      String getName();  
46. }  

二、Field类实例

[java]  view plain  copy

1. package reflect;  
2.   
3. import java.lang.annotation.Annotation;  
4. import java.lang.reflect.Field;  
5. import java.lang.reflect.Modifier;  
6. import java.lang.reflect.ParameterizedType;  
7. import java.lang.reflect.Type;  
8. import java.lang.reflect.TypeVariable;  
9. import java.lang.reflect.WildcardType;  
10. import java.util.Arrays;  
11. import java.util.List;  
12.   
13. /** 
14.  * @author zhangquanit 
15.  */  
16. public class FieldTest {  
17.   
18.     private int mInt; // 普通成员变量  
19.   
20.     public static String mStr; // 静态成员变量  
21.   
22.     @MyAnnotation  
23.     private Object mObject; // 使用了注解的成员变量  
24.   
25.     private List<String> mList; // 泛型字段  
26.   
27.     public static void main(String[] args) throws Exception {  
28.         FieldTest obj = new FieldTest();  
29.         Class<? extends FieldTest> clazz = obj.getClass();  
30.   
31.         /* 
32.          * 普通属性字段的设置和获取 
33.          */  
34.         Field normalField = clazz.getDeclaredField("mInt");  
35.         setAccessible(normalField);  
36.         String filedName=normalField.getName();//mInt  
37.         normalField.set(obj, 100); // 设值  
38.         int mIntValue = normalField.getInt(obj);// 取值 100;  
39.   
40.         /* 
41.          * 静态属性字段的设值和获取 (obj传null) 
42.          */  
43.         Field staticField = clazz.getDeclaredField("mStr");  
44.         setAccessible(staticField);  
45.         staticField.set(null, "static value");  
46.         Object value = staticField.get(null);// static value  
47.   
48.         /* 
49.          * 字段的枚举相关操作 (更多相关信息参照 我写的 Java注解) 
50.          */  
51.         Field annotationField = clazz.getDeclaredField("mObject");  
52.         setAccessible(annotationField);  
53.         Annotation[] declaredAnnotations = annotationField  
54.                 .getDeclaredAnnotations();  
55.         System.out.println(Arrays.toString(declaredAnnotations));  
56.   
57.         /* 
58.          * 泛型字段 
59.          */  
60.         Field genericField = clazz.getDeclaredField("mList");  
61.         setAccessible(genericField);  
62.         Type genericType = genericField.getGenericType();// java.util.List<java.lang.String>  
63.         Class type = genericField.getType(); // interface java.util.List  
64.         getActualType(genericType); //Class类型: class java.lang.String  
65.   
66.     }  
67.   
68.     // 私有的变量，需要设置为可访问  
69.     private static void setAccessible(Field field) {  
70.         if (!field.isAccessible()) {  
71.             field.setAccessible(true);  
72.         }  
73.     }  
74.   
75.     // 获取List中泛型的实际类型  
76.     private static void getActualType(Type genericType) {  
77.         if (genericType instanceof ParameterizedType) {  
78.             ParameterizedType parameterizedType = (ParameterizedType) genericType;  
79.             Type actualType = parameterizedType.getActualTypeArguments()[0];  
80.             if (actualType instanceof TypeVariable) {// 泛型类型，比如T  
81.                 TypeVariable typeVariable = (TypeVariable) actualType;  
82.                 System.out.println("TypeVariable类型: " + typeVariable);  
83.   
84.             } else if (actualType instanceof WildcardType) {// 含通配符? 类型  
85.                 WildcardType wildcardType = (WildcardType) actualType;  
86.                 System.out.println("WildcardType类型: " + wildcardType);  
87.   
88.             } else if (actualType instanceof Class) { // 普通类对象  
89.                 Class cls = (Class) actualType;  
90.                 System.out.println("Class类型: " + actualType); // class  
91.                                                                 // java.lang.String  
92.             }  
93.         }  
94.     }  
95.   
96. }