Java Field 详解

一.主要方法

getType()： 获取属性声明时类型对象（返回class对象）

getGenericType() ： 返回属性声的Type类型

getName() ： 获取属性声明时名字

getAnnotations() ： 获得这个属性上所有的注释

getModifiers() ： 获取属性的修饰

isEnumConstant() ： 判断这个属性是否是枚举类

isSynthetic() ： 判断这个属性是否是 复合类

get(Object obj) ： 取得obj对象这个Field上的值

set(Object obj, Object value) ： 向obj对象的这个Field设置新值value

Field类中最常用的是get(Object obj)和set(Object obj, Object value)这两个方法，所以这两个方法是最重要的。

getType() 和 getGenericType()的区别 ：

1.首先是返回的类型不一样，一个是Class对象一个是Type接口

2.如果属性是一个泛型，从getType（）只能得到这个属性的接口类型。但从getGenericType（）还能得到这个泛型的参数类型。

isEnumConstant()和isSynthetic() ：

对象中如果有属性是枚举类或复合类，用这两个方法返回的值并不是我们想象的true而是false。其实这两个方法是对编译生成的才有效。

二.试验代码

<span style="font-family:Microsoft YaHei;">package test.fortest;
 
import static java.lang.System.out;
 
import java.lang.reflect.Field;
 
import javassist.Modifier;
import test.model.Role;
 
public class FieldTest {
    enum Color {
        Blue,
        Red
    }
     
    class Inner {
    }
     
    public static void main(String args[]) {
        Role role = new Role();
        role.setId("role1");
        role.setUserId("user1");
        role.setRoleName("Role 1");
         
        Field idField =  getDeclaredField(role.getClass(), "id");
        Field childrenField =  getDeclaredField(role.getClass(), "children");
        Field roleTypeField =  getDeclaredField(role.getClass(), "roleType");
        Field userField =  getDeclaredField(role.getClass(), "user");
         
        //获取属性声明时类型对象（返回class对象）
        System.out.println(idField.getType());
        //返回属性声的Type类型
        System.out.println(idField.getGenericType());
        //如果属性是一个泛型，从getType只能得到这个属性的接口类型
        System.out.println(childrenField.getType());
        //如果属性是一个参数化类型，从getGenericType还能得到这个泛型的参数类型
        System.out.println(childrenField.getGenericType());
        //获取属性声明时名字
        System.out.println(idField.getName());
        //获得这个属性上所有的注释
        System.out.println(idField.getAnnotations().length);
        //获取属性的修饰
        System.out.println(Modifier.toString(idField.getModifiers()));
         
        //判断这个属性是否是枚举类
        System.out.println(roleTypeField.isEnumConstant());
        //判断这个属性是否是 复合类
        System.out.println(userField.isSynthetic());
        //FieldTest$Color是Color枚举类编译后的名字。
        isSyntheticOrEnumConstant("test.fortest.FieldTest$Color");
        //FieldTest$Inner是Inner类编译后的名字。
        isSyntheticOrEnumConstant("test.fortest.FieldTest$Inner");
        try {
            //取得对象这个Field上的值
            System.out.println(idField.get(role));
            //向对象的这个Field重新设置值
            idField.set(role, "role2");
            System.out.println(idField.get(role));
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
         
    }
     
    public static Field getDeclaredField(final Class cla, final String fieldName) {
        for (Class superClass = cla; superClass != null; superClass = superClass.getSuperclass()) {
            try {
                return superClass.getDeclaredField(fieldName);
            } catch (NoSuchFieldException e) {
//              e.printStackTrace();
            }
        }
        return null;
    }
     
    public static void isSyntheticOrEnumConstant (String completePackageName) {
        try {
            Class<?> c = Class.forName(completePackageName);
            Field[] flds = c.getDeclaredFields(); 
            for (Field f : flds) {  
                out.format("%-8s [ synthetic=%-5b enum_constant=%-5b ]%n",
                        c.getName() + ":" + f.getName(), f.isSynthetic(), f.isEnumConstant());  
            }  
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } 
    }
}</span>

结果：

<span style="font-family:Microsoft YaHei;">class java.lang.String
class java.lang.String
interface java.util.List
java.util.List<test.model.User>
id
5
public
false
false
test.fortest.FieldTest$Color:Blue [ synthetic=false enum_constant=true  ]
test.fortest.FieldTest$Color:Red [ synthetic=false enum_constant=true  ]
test.fortest.FieldTest$Color:ENUM$VALUES [ synthetic=true  enum_constant=false ]
test.fortest.FieldTest$Inner:this$0 [ synthetic=true  enum_constant=false ]
role1
role2</span>

三.用到的类

<span style="font-family:Microsoft YaHei;">package test.model;
 
import java.util.List;
 
import javax.persistence.Entity;
import javax.persistence.Table;
 
import test.enu.RoleType;
 
@Entity
@Table(schema = "public")
public class Role extends AbsEntity implements IEntity{
    public String roleName;
     
    public String userId;
 
    public List<User> children;
     
    private RoleType roleType = RoleType.Manager;
     
    private User user;
     
    public Role() {}
     
    private Role(String roleName) {
        this.roleName = roleName;
    }
    public String getRoleName() {
        return roleName;
    }
 
    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
 
    public String getUserId() {
        return userId;
    }
 
    public void setUserId(String userId) {
        this.userId = userId;
    }
 
    public String getDisplayString() {
        System.out.println("I am a Role");
        return "Role";
    }
     
}</span>

<span style="font-family:Microsoft YaHei;">packagetest.enu;
 
publicenum RoleType{
    Manager,Employee;
}</span>

<span style="font-family:Microsoft YaHei;">packagetest.model;
 
importjavax.persistence.Column;
importjavax.persistence.Entity;
importjavax.persistence.GeneratedValue;
importjavax.persistence.Id;
importjavax.persistence.ManyToOne;
importjavax.persistence.Table;
 
importorg.hibernate.annotations.AccessType;
importorg.hibernate.annotations.GenericGenerator;
 
@Entity
@Table(name = "users", schema = "public")
publicclass User {
    @Id
    @GeneratedValue(generator = "system-uuid")
    @GenericGenerator(name = "system-uuid", strategy = "uuid.hex")
    @Column(length = 40)
    @AccessType("property")
    privateString id;
     
    privateString loginName;
     
    privateString password;
     
    privateString address;
     
    @ManyToOne
    privateRole role;
 
    publicString getId() {
        returnid;
    }
 
    protectedvoid setId(String id) {
        this.id = id;
    }
 
    publicString getLoginName() {
        returnloginName;
    }
 
    publicvoid setLoginName(String loginName) {
        this.loginName = loginName;
    }
 
    publicString getPassword() {
        returnpassword;
    }
 
    publicvoid setPassword(String password) {
        this.password = password;
    }
 
    publicString getAddress() {
        returnaddress;
    }
 
    publicvoid setAddress(String address) {
        this.address = address;
    }
 
    publicRole getRole() {
        returnrole;
    }
 
    publicvoid setRole(Role role) {
        this.role = role;
    }
}</span>