一、反射简介
反射机制指的是程序在运行时能够获取自身的信息。在JAVA中，只要给定类的名字，那么就可以通过反射机制来获取类的所有信息。
1、反射的应用
- JDBC编程中的：Class.forName("com.mysql.jdbc.Driver.class")；
- 通过文件名找到项目中的文件；
- Hibernate、Struts、Dagger2等框架中都用到了反射机制。
2、反射的特点
- 优点：使用反射机制可以实现动态的创建对象和编译，体现出了很大的灵活性；
- 缺点：反射对性能有影响。
3、反射的原理
JAVA语言编译之后都会生成一个.class文件，而不是生成机器码。反射就是在程序编译之后，通过程序字节码文件找到某一个类、类中的方法以及属性等。
简单来说，反射是JAVA语言在运行的时候拥有的一项自观能力，其实现主要借助于以下四个类：
- Class：类的对象；
- Constructor：类的构造方法；
- Field：类中的属性对象；
- Method：类中的方法对象。
通过这四个类就可以找到并处理JAVA中的几乎所有东西了。
二、常用方法
1、获取类对象
- 通过类名获取Class对象：Class<?> c = Class.forName(“ClassName”);（这里的ClassName是完全的路径，需要包括包路径）
- 通过Class对象获得具体类对象：Object o = (Object) c.newInstance();
2、获取类中的构造方法
以下代码中的c是2.1中获得的Class<?>类型的变量
- 根据指定参数类型获取public构造方法：Constructor con = c.getConstructor(Class<?> … paramTypes);
- 获得所有public构造方法：Constructor[] cons = c.getConstructors();
- 根据指定参数类型获取任意访问权限的构造方法：Constructor con = c.getDeclaredConstructor(Class<?> … paramTypes);
- 获得所有任意访问权限的构造方法：Constructor[] cons = c.getDeclaredConstructors();
3、获取类中的方法
以下代码中的c是2.1中获得的Class<?>类型的变量
- 根据方法名和指定参数类型获取public方法：Method m = c.getMethod(String mName, Class<?> … paramTypes);
- 获得所有public方法：Method[] ms= c.getMethods();
- 根据方法名和指定参数类型获得任意访问权限的方法：Method m = c.getDeclaredMethod(String mName, Class<?> …paramTypes);
- 获得所有任意访问权限的方法：Method[] ms = c.getDeclaredMethods();
4、获取类中的变量
以下代码中的c是2.1中获得的Class<?>类型的变量
- 根据变量名获取public变量：Field f =c.getField(String name);
- 获得所有public变量：Field[] fs= c.getFields();
- 根据变量名获取所有任意访问权限的变量：Field f = c.getDeclaredField(String name);
- 获得所有任意访问权限的变量：Field[] fs = c.getDeclaredFields();
5、获取其他数据
- 获取类实现的所有接口：Class<?>[] interfaces = c.getInterfaces();
- 获取类继承的父类：Class<?> parent = c.getSuperclass();
- 获取修饰符：String modifier = Modifier.toString(X.getModifiers()); //X是类、方法、属性、构造方法等
- 获取方法的返回值类型：String returnType = m.getReturnType().getSimpleName();
- 获取属性的类型：String type = f.getType().getSimpleName();
- 获取名称：String name = X.getName(); //X是类、方法、属性、构造方法等
- 调用方法：m.invoke(clazz, Class<?> … paramTypes); //clazz是类对象
- 获取属性值：Object o = f.get(clazz); //clazz是类对象
三、代码演示
以下代码是目标类，我们的测试类会从这个类中取出各种数据做测试：
public class DemoClass {
// public修饰的int类型的变量
public Integer publicInteger;
// public修饰的String类型的变量
public String publicString;
// private修饰的int类型的变量
protected Integer privateInteger;
// private修饰的String类型的变量
protected String privateString;
// public修饰的无参构造方法
public DemoClass() {
this.publicInteger = 10;
this.privateInteger = 20;
this.publicString = "Public String";
this.privateString = "Private String";
}
// public修饰的四个参数的构造方法，参数类型：int,String,int,String
public DemoClass(Integer publicInteger, String publicString, Integer privateInteger, String privateString) {
this.publicInteger = publicInteger;
this.publicString = publicString;
this.privateInteger = privateInteger;
this.privateString = privateString;
}
// private修饰的两个参数的构造方法，参数类型：int,int
protected DemoClass(Integer publicInteger, Integer privateInteger) {
this.publicInteger = publicInteger;
this.privateInteger = privateInteger;
}
// public修饰的无参的方法，返回int变量
public int getPublicInteger() {
return publicInteger;
}
// public修饰的四个参数的方法，参数类型：int,int,String,String，无返回值
public void setParameters(Integer publicInteger, Integer privateInteger, String publicString,
String privateString) {
this.publicInteger = publicInteger;
this.privateInteger = privateInteger;
this.publicString = publicString;
this.privateString = privateString;
}
// private修饰的两个参数的方法，参数类型：int,int，返回boolean类型的变量
protected boolean setSomeParams(Integer publicInteger, Integer privateInteger) {
this.publicInteger = publicInteger;
this.privateInteger = privateInteger;
return true;
}
@Override
public String toString() {
return "DemoClass [publicInteger=" + publicInteger + ", publicString=" + publicString + ", privateInteger="
+ privateInteger + ", privateString=" + privateString + "]";
}
}
编写这个类需要注意的有以下几点：
- 变量和参数的类型、方法的返回值类型不能是int、float、double，必须是封装类Integer、Float、Double；
- 用private修饰的变量、方法和构造方法是不能通过反射获取的，使用其他修饰符都能获取到。
以下是测试类中的代码：
public class Test {
public static void main(String[] args) {
try {
/**
* 获取和类有关的数据
*/
// 通过类名得到Class<?>对象
Class<?> clazz = Class.forName("com.itgungnir.testreflect.democlass.DemoClass");
System.out.println("Class Created");
// 获取这个类实现的接口
System.out.println("----------------------------------------------------------------------------");
Class<?>[] interfaces = clazz.getInterfaces();
if (interfaces.length == 0) {
System.out.println("No Interfaces Implemented");
}
// 获取这个类的父类
System.out.println("----------------------------------------------------------------------------");
Class<?> parent = clazz.getSuperclass();
System.out.println("Parent -----> " + parent.getName());
/**
* 获取和构造方法有关的数据
*/
// 通过Class<?>对象获取DemoClass类的对象
// newInstance()方法调用的是无参的构造方法，如果没有无参的构造方法，则会报错
System.out.println("----------------------------------------------------------------------------");
DemoClass c = (DemoClass) clazz.newInstance();
System.out.println(c.toString());
// 获取DemoClass对象中public修饰的无参构造方法
System.out.println("----------------------------------------------------------------------------");
Constructor<?> con1 = clazz.getConstructor();
c = (DemoClass) con1.newInstance();
System.out.println(c.toString());
// 获取DemoClass对象中public修饰的四个参数的构造方法，参数类型：Integer,String,Integer,String
System.out.println("----------------------------------------------------------------------------");
Constructor<?> con2 = clazz.getConstructor(Integer.class, String.class, Integer.class, String.class);
c = (DemoClass) con2.newInstance(100, "", 100, "aaa");
System.out.println(c.toString());
// 获取DemoClass对象中protected修饰的两个参数的构造方法，参数类型：Integer,Integer
System.out.println("----------------------------------------------------------------------------");
Constructor<?> con3 = clazz.getDeclaredConstructor(Integer.class, Integer.class);
c = (DemoClass) con3.newInstance(55, 66);
System.out.println(c.toString());
// 获取DemoClass对象中所有public修饰的构造方法
System.out.println("----------------------------------------------------------------------------");
Constructor<?>[] cons1 = clazz.getConstructors();
c = (DemoClass) cons1[0].newInstance(0, "Hello", 111111, "World");
System.out.println(c.toString());
c = (DemoClass) cons1[1].newInstance();
System.out.println(c.toString());
// 获取DemoClass对象中所有任意访问权限的构造方法
System.out.println("----------------------------------------------------------------------------");
Constructor<?>[] cons2 = clazz.getDeclaredConstructors();
c = (DemoClass) cons2[0].newInstance(-1, -2);
System.out.println(c.toString());
c = (DemoClass) cons2[1].newInstance(0, "Hello", 111111, "World");
System.out.println(c.toString());
c = (DemoClass) cons2[2].newInstance();
System.out.println(c.toString());
/**
* 获取和变量有关的数据
*/
// 获取DemoClass对象中public修饰的Integer类型的变量publicInteger
// 获取属性值时传入的Object类型的参数是DemoClass类的对象
System.out.println("----------------------------------------------------------------------------");
Field f1 = clazz.getField("publicInteger");
System.out.println(f1.get(c));
// 获取DemoClass对象中public修饰的String类型的变量privateInteger
System.out.println("----------------------------------------------------------------------------");
Field f2 = clazz.getDeclaredField("privateInteger");
System.out.println(f2.get(c));
// 获取DemoClass对象中public修饰的Integer类型的变量publicString
System.out.println("----------------------------------------------------------------------------");
Field f3 = clazz.getField("publicString");
System.out.println(f3.get(c));
// 获取DemoClass对象中protected修饰的String类型的变量privateString
System.out.println("----------------------------------------------------------------------------");
Field f4 = clazz.getDeclaredField("privateString");
System.out.println(f4.get(c));
// 获取DemoClass对象中所有public修饰的变量
System.out.println("----------------------------------------------------------------------------");
Field[] fs1 = clazz.getFields();
for (Field f : fs1) {
System.out.println(Modifier.toString(f.getModifiers()) + " " + f.getType().getSimpleName() + " "
+ f.getName() + " = " + f.get(c) + ";");
}
// 获取DemoClass对象中所有任意访问权限的变量
System.out.println("----------------------------------------------------------------------------");
Field[] fs2 = clazz.getDeclaredFields();
for (Field f : fs2) {
System.out.println(Modifier.toString(f.getModifiers()) + " " + f.getType().getSimpleName() + " "
+ f.getName() + " = " + f.get(c) + ";");
}
/**
* 获取和方法有关的数据
*/
// 获取DemoClass对象中public修饰的无参方法getPublicInteger，返回Integer类型变量
System.out.println("----------------------------------------------------------------------------");
Method m1 = clazz.getMethod("getPublicInteger");
System.out.println(m1.invoke(c));
// 获取DemoClass对象中public修饰的四个参数的方法setParameters，参数类型：Integer,Integer,String,String，无返回值
System.out.println("----------------------------------------------------------------------------");
Method m2 = clazz.getMethod("setParameters", Integer.class, Integer.class, String.class, String.class);
m2.invoke(c, 111, 1111, "abc", "abcdef");
System.out.println(c.toString());
// 获取DemoClass对象中protected修饰的两个参数的方法setSomeParams，参数类型：Integer,Integer，返回boolean类型变量
System.out.println("----------------------------------------------------------------------------");
Method m3 = clazz.getDeclaredMethod("setSomeParams", Integer.class, Integer.class);
System.out.println(m3.invoke(c, 0, 0));
// 获取DemoClass对象中所有public修饰的方法（包括Object类中的public方法）
System.out.println("----------------------------------------------------------------------------");
Method[] ms1 = clazz.getMethods();
for (Method m : ms1) {
System.out.println(Modifier.toString(m.getModifiers()) + " " + m.getReturnType().getSimpleName() + " "
+ m.getName() + "(){...}");
}
// 获取DemoClass对象中所有任意访问权限的方法（所有自定义的方法）
System.out.println("----------------------------------------------------------------------------");
Method[] ms2 = clazz.getDeclaredMethods();
for (Method m : ms2) {
System.out.println(Modifier.toString(m.getModifiers()) + " " + m.getReturnType().getSimpleName() + " "
+ m.getName() + "(){...}");
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
}
要想得到不同的数据，只需要参照上面的代码进行编写即可。
唯一值得注意的是，当调用getFields()、getDeclaredFields()、getMethods()、getDeclaredMethods()、getConstructors()、getDeclaredConstructors()等能获取数组类型的结果的方法时，返回的数组中的方法、变量或构造方法的顺序和类中定义的顺序是反过来的！
以上就是对Java中反射的一些总结，希望对大家有帮助！