Java反射的简单应用

Java反射能够得到Class中Private的构造函数，方法和成员。

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- 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() -- 获得类声明的所有字段

用于获得方法信息函数：
Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法
Method[] getMethods() -- 获得类的所有公共方法
Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法
Method[] getDeclaredMethods() -- 获得类声明的所有方法

测试代码如下：

public class SourceClass {
    public String field1 = "field1";
    private String field2 = "field2";
    
    public SourceClass(){
        System.out.println( "Constructor1 !" );
    }
    
    private SourceClass( String str ){
        System.out.println( "Constructor2 !" );
    }
    
    public String method1(){
        return( "Method1 !" );
    }
    
    private String method2(){
        return( "Method2 !" );
    }
}

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectClass {
    public static void main(String[] arg){
        SourceClass sourceClass = new SourceClass();
        System.out.println( sourceClass.field1 );
        System.out.println( sourceClass.method1() );
        
        try {
            //Private Field
            Field reflectField2 = sourceClass.getClass().getDeclaredField( "field2" );
            reflectField2.setAccessible( true );
            System.out.println( reflectField2.get( sourceClass ) );
            reflectField2.setAccessible( false );
            
            //Private Method
            Method reflectMethod2 = sourceClass.getClass().getDeclaredMethod( "method2" );
            reflectMethod2.setAccessible( true );
            System.out.println( reflectMethod2.invoke( sourceClass ).toString() );
            reflectMethod2.setAccessible( false );
            
            //Private Constructor
            Constructor reflectConstructor = sourceClass.getClass().getDeclaredConstructor( String.class );
            reflectConstructor.setAccessible( true );
            reflectConstructor.newInstance( new String("None") );
            reflectConstructor.setAccessible( false );
        }
        catch ( SecurityException e ) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch ( NoSuchFieldException e ) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch ( IllegalArgumentException e ) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch ( IllegalAccessException e ) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch ( NoSuchMethodException e ) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch ( InstantiationException e ) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch ( InvocationTargetException e ) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}