【案例】接下来让我们取得其他类的全部属性吧,最后我讲这些整理在一起,也就是通过class取得一个类的全部框架
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
|
class
hello {
public
static
void
main(String[] args) {
Class<?> demo =
null
;
try
{
demo = Class.forName(
"Reflect.Person"
);
}
catch
(Exception e) {
e.printStackTrace();
}
System.out.println(
"===============本类属性========================"
);
// 取得本类的全部属性
Field[] field = demo.getDeclaredFields();
for
(
int
i =
0
; i < field.length; i++) {
// 权限修饰符
int
mo = field[i].getModifiers();
String priv = Modifier.toString(mo);
// 属性类型
Class<?> type = field[i].getType();
System.out.println(priv +
" "
+ type.getName() +
" "
+ field[i].getName() +
";"
);
}
System.out.println(
"===============实现的接口或者父类的属性========================"
);
// 取得实现的接口或者父类的属性
Field[] filed1 = demo.getFields();
for
(
int
j =
0
; j < filed1.length; j++) {
// 权限修饰符
int
mo = filed1[j].getModifiers();
String priv = Modifier.toString(mo);
// 属性类型
Class<?> type = filed1[j].getType();
System.out.println(priv +
" "
+ type.getName() +
" "
+ filed1[j].getName() +
";"
);
}
}
}
|
【运行结果】:
===============本类属性========================
private java.lang.String sex;
===============实现的接口或者父类的属性========================
public static final java.lang.String name;
public static final int age;
【案例】其实还可以通过反射调用其他类中的方法:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
class
hello {
public
static
void
main(String[] args) {
Class<?> demo =
null
;
try
{
demo = Class.forName(
"Reflect.Person"
);
}
catch
(Exception e) {
e.printStackTrace();
}
try
{
//调用Person类中的sayChina方法
Method method=demo.getMethod(
"sayChina"
);
method.invoke(demo.newInstance());
//调用Person的sayHello方法
method=demo.getMethod(
"sayHello"
, String.
class
,
int
.
class
);
method.invoke(demo.newInstance(),
"Rollen"
,
20
);
}
catch
(Exception e) {
e.printStackTrace();
}
}
}
|
【运行结果】:
hello ,china
Rollen 20
【案例】调用其他类的set和get方法
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
|
class
hello {
public
static
void
main(String[] args) {
Class<?> demo =
null
;
Object obj=
null
;
try
{
demo = Class.forName(
"Reflect.Person"
);
}
catch
(Exception e) {
e.printStackTrace();
}
try
{
obj=demo.newInstance();
}
catch
(Exception e) {
e.printStackTrace();
}
setter(obj,
"Sex"
,
"男"
,String.
class
);
getter(obj,
"Sex"
);
}
/**
* @param obj
* 操作的对象
* @param att
* 操作的属性
* */
public
static
void
getter(Object obj, String att) {
try
{
Method method = obj.getClass().getMethod(
"get"
+ att);
System.out.println(method.invoke(obj));
}
catch
(Exception e) {
e.printStackTrace();
}
}
/**
* @param obj
* 操作的对象
* @param att
* 操作的属性
* @param value
* 设置的值
* @param type
* 参数的属性
* */
public
static
void
setter(Object obj, String att, Object value,
Class<?> type) {
try
{
Method method = obj.getClass().getMethod(
"set"
+ att, type);
method.invoke(obj, value);
}
catch
(Exception e) {
e.printStackTrace();
}
}
}
// end class
|
【运行结果】:
男
【案例】通过反射操作属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class
hello {
public
static
void
main(String[] args)
throws
Exception {
Class<?> demo =
null
;
Object obj =
null
;
demo = Class.forName(
"Reflect.Person"
);
obj = demo.newInstance();
Field field = demo.getDeclaredField(
"sex"
);
field.setAccessible(
true
);
field.set(obj,
"男"
);
System.out.println(field.get(obj));
}
}
// end class
|
【案例】通过反射取得并修改数组的信息:
1
2
3
4
5
6
7
8
9
10
11
12
|
import
java.lang.reflect.*;
class
hello{
public
static
void
main(String[] args) {
int
[] temp={
1
,
2
,
3
,
4
,
5
};
Class<?>demo=temp.getClass().getComponentType();
System.out.println(
"数组类型: "
+demo.getName());
System.out.println(
"数组长度 "
+Array.getLength(temp));
System.out.println(
"数组的第一个元素: "
+Array.get(temp,
0
));
Array.set(temp,
0
,
100
);
System.out.println(
"修改之后数组第一个元素为: "
+Array.get(temp,
0
));
}
}
|
【运行结果】:
数组类型: int
数组长度 5
数组的第一个元素: 1
修改之后数组第一个元素为: 100
【案例】通过反射修改数组大小
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
|
class
hello{
public
static
void
main(String[] args) {
int
[] temp={
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
};
int
[] newTemp=(
int
[])arrayInc(temp,
15
);
print(newTemp);
System.out.println(
"====================="
);
String[] atr={
"a"
,
"b"
,
"c"
};
String[] str1=(String[])arrayInc(atr,
8
);
print(str1);
}
/**
* 修改数组大小
* */
public
static
Object arrayInc(Object obj,
int
len){
Class<?>arr=obj.getClass().getComponentType();
Object newArr=Array.newInstance(arr, len);
int
co=Array.getLength(obj);
System.arraycopy(obj,
0
, newArr,
0
, co);
return
newArr;
}
/**
* 打印
* */
public
static
void
print(Object obj){
Class<?>c=obj.getClass();
if
(!c.isArray()){
return
;
}
System.out.println(
"数组长度为: "
+Array.getLength(obj));
for
(
int
i =
0
; i < Array.getLength(obj); i++) {
System.out.print(Array.get(obj, i)+
" "
);
}
}
}
|
【运行结果】:
数组长度为: 15
1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 =====================
数组长度为: 8
a b c null null null null null