Java的反射
什么是Java的反射?
在运行期间得到类的各种信息,包括变量、构造器、方法等并对其惊醒操作。这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制
废话不多说,直接上
- 首先创建两个测试类
public abstract class FatherObject implements Runnable {
public void doSomething() {
System.out.println("doSomething......");
}
}
public class ExampleObject extends FatherObject {
public int age = 11;
public String name = "LGZ";
private Integer score = 59;
public void printName() {
System.out.println(name);
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getScore() {
return score;
}
public void setScore(Integer score) {
this.score = score;
}
public ExampleObject() {
}
public ExampleObject(String name) {
}
public ExampleObject(int age, Integer score) {
}
@Override
public void doSomething() {
super.doSomething();
}
@Override
public void run() {
System.out.println("run......");
}
}
2.测试
public class Test {
public static void main(String[] args) {
testReflect(new Object());
}
private static void testReflect(Object obj){
Class exampleObj;
try {
//在JDK中,使用Class对象来保存类的信息,有两种方式
exampleObj = Class.forName("com.kcj.test.ExampleObject");
//exampleObj = ExampleObject.class;
//得到类名
String fullClassName = exampleObj.getName();
String simpleClassName = exampleObj.getSimpleName();
System.out.println(fullClassName);
System.out.println(simpleClassName);
//得到包信息
Package aPackage = exampleObj.getPackage();
System.out.println(aPackage);
//得到父类
Class superClass = exampleObj.getSuperclass();
System.out.println(superClass.getSimpleName());
System.out.println("父类是不是抽象类 " + Modifier.isAbstract(superClass.getModifiers()));
/*
Modifier.isAbstract(int modifiers);
Modifier.isFinal(int modifiers);
Modifier.isInterface(int modifiers);
Modifier.isNative(int modifiers);
Modifier.isPrivate(int modifiers);
Modifier.isProtected(int modifiers);
Modifier.isPublic(int modifiers);
Modifier.isStatic(int modifiers);
Modifier.isStrict(int modifiers);
Modifier.isSynchronized(int modifiers);
Modifier.isTransient(int modifiers);
Modifier.isVolatile(int modifiers);
*/
//得到接口
Class[] classes = superClass.getInterfaces();
System.out.println("父类的接口" + classes[0]);
//构造器
Constructor[] constructors = exampleObj.getConstructors();
for (Constructor constructor : constructors){
System.out.println(constructor.toString());
Class[] parameterTypes = constructor.getParameterTypes();
System.out.println("构造器参数如下========================");
for (Class clz : parameterTypes){
System.out.println("参数类型 " + clz.toString());
}
}
//事先知道要访问的构造方法的参数类型,可以利用如下方法获取指定的构造方法
Constructor constructor = exampleObj.getConstructor(int.class, Integer.class);
System.out.println(constructor.toString());
//根据构造器的各种信息,动态创建一个对象
Object object = constructor.newInstance(1,100);
System.out.println(object.toString());
//得到所有public的变量
Field[] fields = exampleObj.getFields();
for (Field field : fields){
System.out.println("变量为: " + field.toString());
}
//指定一个参数名,然后得到指定的变量
Field field = exampleObj.getField("age");
System.out.println("变量为:" + field.toString());
Constructor constructor1 = exampleObj.getConstructor(String.class);
ExampleObject object1 = ((ExampleObject) constructor1.newInstance("byhieg"));
System.out.println("原先的age是 " + object1.age);
field.set(object1, 10);
System.out.println("更改之后的age是" + object1.age);
//输出类的public方法
Method[] methods = exampleObj.getMethods();
for (Method method : methods){
System.out.println("method = "+ method.getName());
}
//根据方法名和对应的参数得到一个方法
Method method = exampleObj.getMethod("setAge",int.class);
System.out.println(method.getName());
for (Class clz : method.getParameterTypes()){
System.out.println("方法的参数" + clz.getName());
}
//得到方法返回的数据类型
System.out.println("方法返回的数据类型 = "+method.getReturnType().getName());
//通过invoke调用得到的方法
method.invoke(exampleObj.newInstance(),1);
} catch (Exception e) {
e.printStackTrace();
}
}
}