如何利用java反射机制获得修饰符public private等

参照下列方法：package tools.reflect;import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class SeeMethods {

    public static void main(String[] args) {
        Class inspect;
        try {
            if (args.length > 0)
                inspect = Class.forName(args[0]);
            else
                inspect = Class.forName("tools.reflect.SeeMethods");
            Field[] fs = inspect.getDeclaredFields();

            Method[] methods = inspect.getDeclaredMethods();
            for (int i = 0; i < methods.length; i++) {
                Method methVal = methods[i];
                Class returnVal = methVal.getReturnType();
                int mods = methVal.getModifiers();
                String modVal = Modifier.toString(mods);
                Class[] paramVal = methVal.getParameterTypes();
                StringBuffer params = new StringBuffer();
                for (int j = 0; j < paramVal.length; j++) {
                    if (j > 0)
                        params.append(", ");
                    params.append(paramVal[j].getName());
                }
                System.out.println("Method: " + methVal.getName());
                System.out.println("Modifers: " + modVal);
                System.out.println("Return Type: " + returnVal.getName());
                System.out.println("Parameters: " + params);
                System.out.println();
            }
        } catch (ClassNotFoundException e) {
            System.out.println(e.toString());
        }
    }
}
对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：
• Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，
• Constructor[] getConstructors() -- 获得类的所有公共构造函数
• Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)
• Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关) 获得字段信息的 Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：
• Field getField(String name) -- 获得命名的公共字段
• Field[] getFields() -- 获得类的所有公共字段
• Field getDeclaredField(String name) -- 获得类声明的命名的字段
• Field[] getDeclaredFields() -- 获得类声明的所有字段
尽管与构造函数调用类似，在字段方面仍存在一个重要的区别：前两个变量返回可以通过类接入的公共字段的信息 -- 即使它们来自于祖先类。后两个变量返回类直接声明的字段的信息 -- 与字段的接入类型无关。
调用返回的 java.lang.reflect.Field 实例定义所有主类型的 getXXX 和 setXXX 方法，以及与对象引用协作的通用 get 和 set 方法。您可以根据实际的字段类型自行选择一种适当的方法，而 getXXX 方法将自动处理扩展转换(如使用 getInt 方法来检索一个字节值)。获得方法信息的 Class 反射调用与用于构造函数和字段的调用非常类似：
• Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法
• Method[] getMethods() -- 获得类的所有公共方法
• Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法
• Method[] getDeclaredMethods() -- 获得类声明的所有方法
与字段调用一样，前两个变量返回可以通过类接入的公共方法的信息 -- 即使它们来自于祖先类。后两个变量返回类声明的方法的信息，与方法的接入类型无关。
调用返回的 java.lang.reflect.Method 实例定义一种 invoke 方法，您可以用来在正在定义的类的一个实例上调用方法。这种 invoke 方法使用两个参数，为调用提供类实例和参数值数组。
import java.lang.reflect.*;
import javax.swing.*;public class ReflectionTest
{
public static void main(String[] args)
{
String name;
if(args.length > 0)
name = args[0];
else
name = JOptionPane
.showInputDialog("Class name (e.g. java.util.Date): ");
try
{
Class c1 = Class.forName(name);
Class superc1 = c1.getSuperclass();
System.out.print("class " + name);
if(superc1 != null && superc1 != Object.class)
System.out.println(" extends " + superc1.getName());
System.out.print("\n{\n");
printConstructors(c1);
System.out.println();
printMethods(c1);
System.out.println();
printFields(c1);
System.out.println("}");
}
catch(ClassNotFoundException e)
{
e.printStackTrace();
}
System.exit(0);
} public static void printConstructors(Class c1)
{
Constructor[] constructors = c1.getDeclaredConstructors();
for(int i = 0;i < constructors.length;i++)
{
Constructor c = constructors[i];
String name = c.getName();
System.out.print(Modifier.toString(c.getModifiers()));
System.out.print("  " + name + "(");
Class[] paramTypes = c.getParameterTypes();
for(int j = 0;j < paramTypes.length;j++)
{
if(j > 0)
System.out.print(", ");
System.out.print(paramTypes[j].getName());
}
System.out.println(");");
}
} public static void printMethods(Class c1)
{
Method[] methods = c1.getDeclaredMethods();
for(int i = 0;i < methods.length;i++)
{
Method m = methods[i];
Class retType = m.getReturnType();
String name = m.getName();
System.out.print(Modifier.toString(m.getModifiers()));
System.out.print("  " + retType.getName() + " " + name + "(");
Class[] paramTypes = m.getParameterTypes();
for(int j = 0;j < paramTypes.length;j++)
{
if(j > 0)
System.out.print(", ");
System.out.print(paramTypes[j].getName());
}
System.out.println(");");
}
} public static void printFields(Class c1)
{
Field[] fields = c1.getDeclaredFields();
for(int i = 0;i < fields.length;i++)
{
Field f = fields[i];
Class type = f.getType();
String name = f.getName();
System.out.print(Modifier.toString(f.getModifiers()));
System.out.print("  " + type.getName() + " " + name + ";");
}
}
}

调试易

如何利用java反射机制获得修饰符public private等

解决方案 »