概述
一.主要方法
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。其实这两个方法是对编译生成的才有效。
二.试验代码
|
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
|
<strong>
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</strong>
|
三.用到的类
|
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
|
<strong>
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"
;
}
} </strong>
|
|
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;
}
}
|
最后
以上就是欣慰小馒头为你收集整理的Java Field 详解 一.主要方法 二.试验代码 三.用到的类的全部内容，希望文章能够帮你解决Java Field 详解 一.主要方法 二.试验代码 三.用到的类所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复