本文详细探讨了Java中的反射机制，通过Class类获取目标类（如Student类）的构造方法、属性和普通方法。分析了无declared和declared修饰的获取方式，以及调查这些元素的归属类、修饰符、名称和参数类型等。还介绍了如何使用newInstance、invoke等方法进行对象创建和方法调用。
目录
一、编写一个目标类（Student类）
package Test;
public class Student {
public String name;
private String id;
public Student() {
}
private Student(String name) {
this.name = name;
}
private int doHomework(int b,String str) {
System.out.println("正在做作业......");
return b;
}
public void sleep() {
System.out.println("正在睡觉......");
}
}二、构造方法的获取，调查与使用
（1）获取
a.无declared修饰
getConstrutors()方法返回该Class对象表示类包含的所有public构造方法所对应Constructor对象数组。
getConstrutor(Class<?>... parameterTypes)方法用于返回与该Class对象表示类中参数列表相匹配的public构造函数（不含继承）对应的Constructor对象。
package Test;
import java.lang.reflect.Constructor;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Constructor constructor = null;
try {
constructor = clazz.getConstructor();// 获取无参构造方法
System.out.println(constructor.getName());
constructor = clazz.getConstructor(String.class);// 获取有参构造方法
System.out.println(constructor.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
由开头的定义的Student类得，有参构造方法为private修饰而getConstrutors()方法只能获取public修饰的方法，所以系统报错
b.declared修饰
getDeclaredConstructors() 方法用于返回一个该Class对象表示类中声明的所有构造方法（不区分访问权限）对应的Constructor对象数组。
getDeclaredConstructor(Class<?>... parameterTypes)用于返回与该Class对象表示类中定义的形参类型相匹配的构造方法（不区分访问权限）的Constructor对象。
package Test;
import java.lang.reflect.Constructor;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Constructor constructor = null;
try {
constructor = clazz.getDeclaredConstructor();// 获取无参构造方法
System.out.println(constructor.getName());
constructor = clazz.getDeclaredConstructor(String.class);// 获取有参构造方法
System.out.println(constructor.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}
因为declared声明的方法不区分权限，因此两个构造方法都能被获取。
（2）调查
a、构造方法的归属类
getDeclaringClass()方法用于返回声明Constructor对象对应构造方法的类的Class对象。
package Test;
import java.lang.reflect.Constructor;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Constructor constructor = null;
try {
constructor = clazz.getDeclaredConstructor();// 获取无参构造方法
clazz = constructor.getDeclaringClass();//获取归属类
System.out.println(clazz.getName());
constructor = clazz.getDeclaredConstructor(String.class);// 获取有参构造方法
clazz = constructor.getDeclaringClass();//获取归属类
System.out.println(clazz.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果 ：
b、构造方法的修饰符
getModifiers()方法用于以整数形式返回Constructor对象表示的构造函数的修饰符。后期可用toString（）方法将其转换为字符串
package Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Constructor constructor = null;
int result = 0;
try {
constructor = clazz.getDeclaredConstructor();// 获取无参构造方法
result=constructor.getModifiers();//获取修饰符
System.out.println(Modifier.toString(result));//转换为字符串
constructor = clazz.getDeclaredConstructor(String.class);// 获取有参构造方法
result=constructor.getModifiers();//获取修饰符
System.out.println(Modifier.toString(result));
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
c、构造方法的名称
getName()方法用于以字符串形式返回Constructor对象所表示得构造方法的名称。
package Test;
import java.lang.reflect.Constructor;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Constructor constructor = null;
String str = null;
try {
constructor = clazz.getDeclaredConstructor();// 获取无参构造方法
str=constructor.getName();//获取方法名（即类名）
System.out.println(str);//转换为字符串
constructor = clazz.getDeclaredConstructor(String.class);// 获取有参构造方法
str=constructor.getName();
System.out.println(str);
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
d、构造方法的参数类型
getParameterTypes()方法用于返回由Constructor对象所表示的构造方法的形参类型对应Class对象组成的数组此 。如果构造方法没有参数，则数组长度为0。
package Test;
import java.lang.reflect.Constructor;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Constructor constructor = null;
String str = null;
try {
constructor = clazz.getDeclaredConstructor(String.class);// 获取有参构造方法
Class [] clazzs = constructor.getParameterTypes();
for (Class cla : clazzs) {
System.out.println(cla.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果（因为无参构造方法返回数组长度为0，所以这里不再演示）：
（3）使用（创建对象）
newInstance(Object... initargs)方法：使用此Constructor对象表示的构造方法来创建声明该构造方法类的新对象。initargs为传入该构造方法中的参数，如果该构造方法没有参数，则可设定为null或一个长度为0的数组。
package Test;
import java.lang.reflect.Constructor;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Constructor constructor = null;
String str = null;
try {
constructor = clazz.getDeclaredConstructor(String.class);// 获取有参构造方法
constructor.setAccessible(true);
Object obj = constructor.newInstance("jim");//对象上转型
Student stu = (Student)obj;//对象下转型
System.out.println(stu.name);
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
三、普通方法的获取，调查与使用
（1）获取
a.无declared修饰
getMethods()方法返回一个该Class对象表示类或接口中所有public方法（含继承的）对应的Method对象数组。
getMethod(String methodName, Class<?>... parameterTypes)方法用于返回与该Class对象表示类或接口中方法名和方法形参类型相匹配的public方法（含继承的）的Method对象。
package Test;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Method [] methods = null;
String str = null;
try {
methods = clazz.getMethods();
for (Method method : methods) {
System.out.println(method.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
连继承自Object类的方法也被输出 。
b.declared修饰
package Test;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Method [] methods = null;
String str = null;
try {
methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
（2）调查
a、普通方法的归属类
getDeclaringClass()方法用于返回声明Method对象表示方法的类或接口的 Class 对象。
package Test;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Method [] methods = null;
String str = null;
try {
methods = clazz.getDeclaredMethods();
for (Method method : methods) {
clazz = method.getDeclaringClass();
System.out.println(clazz.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
b、普通方法的修饰符
getModifiers()方法用于以整数形式返回此Method对象所表示方法的修饰符。应该使用Modifier类中的toString方法对所返回的整数进行解码。
package Test;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Method [] methods = null;
String str = null;
try {
methods = clazz.getDeclaredMethods();
for (Method method : methods) {
int mod = method.getModifiers();
System.out.println(Modifier.toString(mod));
}
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
c、普通方法的名称
getName()方法用于返回方法名。
package Test;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Method [] methods = null;
String str = null;
try {
methods = clazz.getDeclaredMethods();
for (Method method : methods) {
String name = method.getName();
System.out.println(name);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
d、普通方法的参数类型
getParameterTypes()方法用于返回由Method对象代表方法的形参类型对应Class对象组成的数组。如果方法没有参数，则数组长度为 0。
package Test;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Method method = null;
String str = null;
try {
method = clazz.getDeclaredMethod("doHomework",Integer.TYPE,String.class);
Class<?>[] name = method.getParameterTypes();
for (Class<?> class1 : name) {
System.out.println(class1.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
e、普通方法的返回值类型
getReturnType()方法用于返回Method对象所表示的方法的返回值类型所对应的Class对象。
package Test;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Method method = null;
String str = null;
try {
method = clazz.getDeclaredMethod("doHomework",Integer.TYPE,String.class);
clazz = method.getReturnType();
System.out.println(clazz.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
（3）使用
Object invoke(Object obj, Object... args)方法用于调用Method对象指代的方法并返回Object类型结果。obj表示该方法所在类实例，如果方法时静态的则obj可以指定为null; args表示传入该方法的参数，如果方法没有参数，则args数组长度可以为 0 或 null 。
package Test;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
Method method = null;
String str = null;
try {
Student student = new Student();
method = clazz.getDeclaredMethod("doHomework",Integer.TYPE,String.class);
method.setAccessible(true);//获得调用权限
Object obj = method.invoke(student, 1,"tom");
System.out.println(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
四、属性的获取，调查与使用
（1）获取
a.无declared修饰
Field[] getFields()方法用于返回一个该Class对象表示类或接口中所有public属性（含继承的）对应的Field对象数组，。
Field getField(String fieldName)方法用于返回该Class对象表示类或接口中与指定属性名（含继承的）相同的public 属性对应的Field对象。
package Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
String str = null;
try {
Field [] field = clazz.getFields();
for (Field field2 : field) {
System.out.println(field2.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
b.declared修饰
Field[] getDeclaredFields()方法用于返回一个该Class对象表示类或接口内定义的所有属性（不含继承的）对应的Field对象数组，。
Field getDeclaredField(String fieldName)方法用于返回一个与该Class对象表示类或接口内定义的属性名（不含继承的）相匹配的属性相对应的Field对象。
package Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
String str = null;
try {
Field [] field = clazz.getDeclaredFields();
for (Field field2 : field) {
System.out.println(field2.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
因为该方法忽略访问权限，所以被private修饰的id属性也能被获得：
（2）调查
a、属性的归属类
getDeclaringClass()方法用于返回声明Field对象表示字段的类或接口所对应的Class对象。
package Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
String str = null;
try {
Field [] field = clazz.getDeclaredFields();
for (Field field2 : field) {
clazz = field2.getDeclaringClass();
System.out.println(clazz.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
b、属性的修饰符
getModifiers()方法用于以整数形式返回Field对象表示的字段的修饰符。
package Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
String str = null;
try {
Field [] field = clazz.getDeclaredFields();
for (Field field2 : field) {
int mod = field2.getModifiers();
System.out.println(Modifier.toString(mod));
}
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
c、属性的数据类型或类
getType()方法用于返回Field对象所表示字段的数据类型所对应的Class对象（推荐）。
package Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
String str = null;
try {
Field [] field = clazz.getDeclaredFields();
for (Field field2 : field) {
clazz = field2.getType();
System.out.println(clazz.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
d、属性的名称
getName()方法用于返回Field对象表示字段的名称。
package Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
String str = null;
try {
Field [] field = clazz.getDeclaredFields();
for (Field field2 : field) {
str = field2.getName();
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
（3）使用
set(Object obj, Object value)方法用于为Field对象表示属性设置新值。obj为该属性所在类创建的对象，如果该属性为静态的则课设置为null;value为该属性新值。
package Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Test {
public static void main(String[] args) {
// 反射是一种新的操作类中属性，构造方法和普通方法的机制
Class clazz = null;
clazz = Student.class;
String str = null;
try {
Student student = new Student();
Field field = clazz.getField("name");
field.set(student, "jim");
Object obj = field.get(student);
System.out.println(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果：
综上，反射无非这么一句话：
获取一律用get，能否获取看declared，使用需要看对象，能否使用看setAccessible。
扫一扫
1505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
