在实际开发中，通过反射取得类的实例是应用最多的地方，当然，反射机制所提供的功能远不止这些，还可以通过反射得到一个类的完整结构，那么这就要使用到 java.lang.reflect 包中的以下功能：
（1）Constructor:表示类中的构造方法。
（2）Field ：表示类中的属性。
（3）Method: 表示类中的方法。
这 3 个类都是 AccessibleObject 类的子类，如图：
Person 类
package self.learn.reflect;
public interface China { // 定义 China 接口
public static final String NATIONAL = "China"; // 定义全局常量
public static final String AUTHOR = "李清照";
public void sayChina(); // 无参抽象方法
public String sayHello(String name, int age); // 定义有参抽象方法
}
package self.learn.reflect;
public class Person implements China{ // 定义 Person 类实现比较器
private String name;
private int age;
public Person() {
}
public Person(String name) {
this.name = name;
}
public Person(String name, int age) {
this(name);
this.setAge(age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void sayChina() { // 覆写方法，输出信息
System.out.println("作者:"+AUTHOR+", 国籍"+NATIONAL);
}
public String sayHello(String name, int age) {
return name+", 你好！我今年"+age+"岁了";
}
@Override
public String toString() { // 覆写 toString() 方法
//return "Person [name=" + name + ", age=" + age + "]";
return "姓名："+this.name+", 年龄："+this.age;
}
}
1 取得所实现的全部接口
要取得一个类所实现的全部接口，则必须使用 Class 类中的 getInterfaces() 方法。此方法定义如下：
public Class[] getInterfaces()
getInterfaces() 方法 返回一个 Class 类的对象数组，然后直接利用 Class 类中的 getName() 方法取得类的名称。
实例 1 代码：取得person 类实现的全部接口
package self.learn.reflect;
public class GetClassDemo01 {
public static void main(String[] args) {
Class<?> c = null; // 指定泛型
try {
c = Class.forName("self.learn.reflect.Person"); // 传入要实例化类的完整的包.类名称
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?> c1[] = c.getInterfaces(); // 取得实现的全部接口
for(int i = 0; i < c1.length;i++) {
System.out.println("实现的接口名称: "+c1[i].getName());
}
}
}
运行结果截图：
2 取得父类
一个类可以实现多个接口，但是只能继承一个父类，所以如果想要取得一个类的父类，可以直接使用 Class 类中的 getSuperClass()方法。此方法定义如下：
public Class<? super T> getSuperClass()
此方法返回的是 Class 实例，和之前的接口一样，可以通过 getName()方法取得类的名称。
实例 2 代码：取得person 类的父类
package self.learn.reflect;
public class GetClassDemo01 {
public static void main(String[] args) {
Class<?> c1 = null; // 指定泛型
try {
c1 = Class.forName("self.learn.reflect.Person"); // 传入要实例化类的完整的包.类名称
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?> c2 = c1.getSuperclass(); // 取得父类
System.out.println("父类名称: "+c2.getName());
}
}
运行结果截图：
Person 类在编写的时候没有明确的继承一个父类，所以默认继承 Object 类。
3 取得全部的构造方法
要取得一个类中的全部构造方法，则必须使用 Class 类中的 getConstructors()方法
实例 3 代码：取得person 类的全部的构造方法
package self.learn.reflect;
import java.lang.reflect.Constructor;
public class GetClassDemo01 {
public static void main(String[] args) {
Class<?> c1 = null; // 指定泛型
try {
c1 = Class.forName("self.learn.reflect.Person"); // 传入要实例化类的完整的包.类名称
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Constructor<?> cons[] = c1.getConstructors(); // 全部的构造方法
for(int i = 0; i < cons.length; i++) {
System.out.println("构造方法: "+cons[i]);
}
}
}
运行结果截图：
上面的代码确实取得了全部的构造方法，取得时是直接通过输出 Constructor 对象得到的完整信息，是比较全的信息，。当然，用户也可以手工拼凑出信息。
实例 4 代码：取得一个类的全部的构造方法
package self.learn.reflect;
import java.lang.reflect.Constructor;
public class GetClassDemo01 {
public static void main(String[] args) {
Class<?> c1 = null; // 指定泛型
try {
c1 = Class.forName("self.learn.reflect.Person"); // 传入要实例化类的完整的包.类名称
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Constructor<?> cons[] = c1.getConstructors(); // 全部的构造方法
for(int i = 0; i < cons.length; i++) { // 循环输出
Class<?> p[] = cons[i].getParameterTypes(); // 列出构造中的参数类型
System.out.print("构造方法: ");
System.out.print(cons[i].getModifiers()+" "); // 取出权限
System.out.print(cons[i].getName()); // 输出构造方法名称
System.out.print("("); // 输出 (
for(int j = 0; j < p.length;j++) { // 循环输出
System.out.print(p[j].getName()+" arg"+i); // 打印参数类型
if(j < p.length-1) {
System.out.print(","); // 输出 ","
}
}
System.out.println("){ }"); // 输出"){ }"
}
}
}
运行结果截图：
从程序的运行结果中可以发现，已经取得了构造方法的方法名称及参数类型，但是在取得权限的时候却发现返回的是一个数字而不是 public,这是因为在整个 Java 中对于方法的修饰符是使用一定的数字表示出来的，如果要想把这个数字还原成用户可以看懂的关键字，则必须靠 Modifier 类完成，此类定义在 java.lang.reflect 包中。直接使用 Modifier 类的以下方法即可将修饰符还原：
public static String toString（int mod）
实例 5 代码：使用 Modifier 还原修饰符
package self.learn.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
public class GetClassDemo01 {
public static void main(String[] args) {
Class<?> c1 = null; // 指定泛型
try {
c1 = Class.forName("self.learn.reflect.Person"); // 传入要实例化类的完整的包.类名称
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Constructor<?> cons[] = c1.getConstructors(); // 全部的构造方法
for(int i = 0; i < cons.length; i++) { // 循环输出
Class<?> p[] = cons[i].getParameterTypes(); // 列出构造中的参数类型
System.out.print("构造方法: ");
int mo = cons[i].getModifiers();
System.out.print(Modifier.toString(mo)+" "); // 取出权限
System.out.print(cons[i].getName()); // 输出构造方法名称
System.out.print("("); // 输出 (
for(int j = 0; j < p.length;j++) { // 循环输出
System.out.print(p[j].getName()+" arg"+i); // 打印参数类型
if(j < p.length-1) {
System.out.print(","); // 输出 ","
}
}
System.out.println("){ }"); // 输出"){ }"
}
}
}
运行结果截图：
从上面的程序运行结果中可以发现，使用 Modifier 将取出的修饰符数字还原成了用户可以看的懂的权限修饰符
4 取得全部方法
要取得一个类中的全部方法，可以使用 Class 类中的 getMethods()方法，此方法返回一个 Method 类的对象数组，而如果要想进一步取得方法的具体信息，例如，方法的参数，抛出的异常，则就必须依靠 Method 类，此类中的常用方法如表：
| 序号 | 方法 | 类型 | 描述 |
|---|---|---|---|
| 1 | public int getModifiers() | 普通 | 取得本方法的访问修饰符 |
| 2 | public String getName() | 普通 | 取得方法的名称 |
| 3 | public Class<?>[] getParameterTypes() | 普通 | 得到方法的全部参数类型 |
| 4 | public Class<?>[] getReturnType() | 普通 | 得到方法的返回值类型 |
| 5 | public Class<?>[] getExceptionTypes() | 普通 | 得到一个方法的全部抛出异常 |
| 6 | public Object invoke( Object obj,Object...args)throws IllegalAccessException,IllegalArgumentException,InvocationTargetException | 普通 | 通过反射调用类中的方法，此方法在后面将为读者介绍 |
实例 6 代码：取得一个类的全部方法定义
package self.learn.reflect;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class GetClassDemo01 {
public static void main(String[] args) {
Class<?> c1 = null; // 指定泛型
try {
c1 = Class.forName("self.learn.reflect.Person"); // 传入要实例化类的完整的包.类名称
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Method m[] = c1.getMethods(); // 取得全部的方法
for(int i = 0; i < m.length; i++) { // 循环输出
Class<?> r = m[i].getReturnType(); // 得到方法的返回值类型
Class<?> p[] = m[i].getParameterTypes(); // 得到全部参数类型
int xx = m[i].getModifiers(); // 得到方法的修饰符
System.out.print(Modifier.toString(xx)+" "); // 还原修饰符
System.out.print(r.getName()+" "); // 得到方法名称
System.out.print("("); // 输出"("
for(int j = 0; j < p.length;j++) {
System.out.print(p[j].getName()+" "+"arg"+j); // 循环输出参数
if( j < p.length - 1 ) { // 判断是否输出","
System.out.print(",");
}
}
Class<?> ex[] = m[i].getExceptionTypes(); // 得到全部的异常抛出
if(ex.length>0) { // 判断是否有异常
System.out.print(") throws ");
}else {
System.out.print(")");
}
for(int k = 0; k < ex.length; k++) {
System.out.print(ex[k].getName()); // 输出异常信息
if(k < ex.length - 1) { // 判断是否输出","
System.out.print(",");
}
}
System.out.println(); // 换行
}
}
}
运行结果截图：
从程序的运行结果可以发现，程序不仅将 Person 类的方法输出，也把从 Object 类中继承而来的方法同样进行了输出。
开发工具是利用反射的原理
在 IDE 进行程序开发的时候，基本都是带随笔提示功能的，即使用一个“.”就可以找到一个类的全部方法，实际上 这个功能就是利用反射方式完成的。
5 取得全部属性
在反射操作中同样也可以取得一个类中的全部属性，但是在取得属性的时候有以下两种不同操作。
（1）得到实现的接口或父类中的公共属性：public Field[] getFields() throws SecurityException。
（2）得到本类中的全部属性：public Field[] getDeclareFields() throws SecurityException。
以上方法返回的都是 Field 的数组，每一个 Field 对象就表示类中的一个属性，要想取得属性的进一步信息，就需要使用如表方法：
| 序号 | 方法 | 类型 | 描述 |
|---|---|---|---|
| 1 | public Object get(Object obj)throws IllegalArgumentException,IllegalAccessException | 普通 | 得到一个对象中属性的具体内容 |
| 2 | public void set(Object obj,Object value)throws IllegalArgumentException,IllegalAccessException | 普通 | 设置指定对象中属性的具体内容 |
| 3 | public int getModifiers() | 普通 | 得到属性的修饰符 |
| 4 | public String getName() | 普通 | 返回此属性的名称 |
| 5 | public boolean isAccessible() | 普通 | 判断此属性是否可被外部访问 |
| 6 | public void setAccessible(boolean flag) throws SecurityException | 普通 | 设置一个属性是否可被外部访问 |
| 7 | public static void setAccessible(AccessibleObject[] array,boolean flag) throws SecurityException | 普通 | 将一组属性设置是否可被外部访问 |
| 8 | public String toString() | 普通 | 返回 Field 类的信息 |
实例 7 代码：取得 Person 类中的属性
package self.learn.reflect;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class GetClassDemo01 {
public static void main(String[] args) {
Class<?> c1 = null; // 指定泛型
try {
c1 = Class.forName("self.learn.reflect.Person"); // 传入要实例化类的完整的包.类名称
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
{ // 普通代码块
Field f[] = c1.getDeclaredFields(); // 取得本来属性
for(int i = 0; i < f.length; i++) { // 循环输出
Class<?> r = f[i].getType(); // 取得属性的类型
int mo = f[i].getModifiers(); // 取得修饰符数字
String priv = Modifier.toString(mo); // 取得属性修饰符
System.out.print("本类属性: ");
System.out.print(priv+" "); // 输出修饰符
System.out.print(r.getName()+" "); // 输出属性类型
System.out.print(f[i].getName()); // 输出属性名称
System.out.println(";"); // 换行
}
}
System.out.println("-------------------");
{ // 普通代码块
Field f[] = c1.getFields(); // 取得父类公共属性
for(int i = 0; i < f.length; i++) {
Class<?> r = f[i].getType(); // 取得属性的类型
int mo = f[i].getModifiers(); // 取得修饰符数字
String priv = Modifier.toString(mo); // 取得属性修饰符
System.out.print("父类属性: ");
System.out.print(priv+" "); // 输出修饰符
System.out.print(r.getName()+" "); // 输出属性类型
System.out.print(f[i].getName()); // 输出属性名称
System.out.println(";"); // 换行
}
}
}
}
运行结果截图：
165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
