一.主要方法

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

getGenericType() ： 返回属性的泛型类型

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。其实这两个方法是对编译生成的才有效。

二.试验代码

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();

}

}

}

结果：

class java.lang.String

class java.lang.String

interface java.util.List

java.util.List

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

三.用到的类

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 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";

}

}

package test.enu;

public enum RoleType{

Manager,Employee;

}

package test.model;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.ManyToOne;

import javax.persistence.Table;

import org.hibernate.annotations.AccessType;

import org.hibernate.annotations.GenericGenerator;

@Entity

@Table(name = "users", schema = "public")

public class User {

@Id

@GeneratedValue(generator = "system-uuid")

@GenericGenerator(name = "system-uuid", strategy = "uuid.hex")

@Column(length = 40)

@AccessType("property")

private String id;

private String loginName;

private String password;

private String address;

@ManyToOne

private Role role;

public String getId() {

return id;

}

protected void setId(String id) {

this.id = id;

}

public String getLoginName() {

return loginName;

}

public void setLoginName(String loginName) {

this.loginName = loginName;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

public Role getRole() {

return role;

}

public void setRole(Role role) {

this.role = role;

}

}