目录[-]
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。其实这两个方法是对编译生成的才有效。
?
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 |
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(); } } } |
结果：
?
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
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 |
?
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
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"; }
} |
?
| 1 2 3 4 5 |
package test.enu;
public enum RoleType{ Manager,Employee; } |
?
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
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; } } |
