Java反射详解及编程示例

反射的用处：

• 在运行时 分析类的能力
• 在运行时查看对象
• 实现通用的数组操作代码
• 利用Method对象，这个对象很像C++中的函数指针

Class类

在Java程序运行期间，Java的运行时系统始终为所有对象维护一个运行时的类型标识，这个信息用来跟踪每个对象所属的类，这些信息被保存在名为Class的类中，以便访问这些信息；

Java中为每个类创建一个Class类的实例对象，用来保存这个类的相关信息；

Class类的相关方法：

java.lang.Class

Class forName(String Classname);
    //返回String对应的类的CLass对象
Fiedl[] getFields();
    //返回一个包含Field对象的数组，这些对象记录了这个类或者其超类的 公有 域；没有域的时候将返回一个长度为0的数组；
Field[] getDeclaredFields();
    //返回这个类的 所有 域，但不包含超类的域；
Method[] getMethods();
    //返回该类及其超类的公有方法；
Method[] getDeclaredMethods();
    //返回该类的所有方法，但不包括该类的超类的方法；
Constructor[] getConstructors();
Constructor[] getDeclaredConstructors();

虚拟机为每个类管理一个Class对象，因此可以调用“==”来比较两个Class对象：

if(a.getClass()==aclassName.class)

利用反射分析类的能力

反射中最重要的机制——检查类的结构

java.lang.reflect中有三个类Field、Method、Constructor分别用于描述类的域;

java.lang.reflect.Field

java.lang.reflect.Method

java.lang.reflect.Constructor

Class getDeclaringClass();
    //返回Class对象的实例
Class[] getExceptionTypes();
    //返回一个用于描述方法抛出的异常的类型的Class对象数组；
int getModifiers();
    //返回一个用于描述修饰符的整数，Modifier类中的相关方法可以分析这个整数
String getName();
    //返回描述方法域名或者构造器的字符串；
Class[] getParameterTypes()
    //返回一个描述参数类型的Class对象数组
ClassgetReturnType()
    //返回一个描述返回类型的Class对象

利用反射打印类的信息：

package algorithm;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.*;

public class ReflectionTest {
    public int testa;
    public int testb;
    private int c;

        public static void main(String args[])
        {
          System.out.println("This is main Class");
          Scanner in=new Scanner (System.in);

          //String className=in.next();

              try{
                  rTest r=new rTest(2);
                  r.getClass();
                  //获得类名对应的类的Class实例
                  Class c=Class.forName("algorithm.rTest");
                  //获得该类名


                  System.out.println("类的名字： "+c.getName());

                  //获得类或者超类的公有域
                  Field[] fields=c.getDeclaredFields();
                  System.out.println("类的所有域: ");
                  for(Field fi:fields){
                      int mod=fi.getModifiers();
                      String modifier=Modifier.isPrivate(mod)?"private":(Modifier.isPublic(mod)?"public":"protected");
                      System.out.println(modifier+"  "+fi);
                  }

                  //获得类或者超类的公有方法
                  Method[]methods=c.getDeclaredMethods();
                  System.out.println("类的公有方法: ");
                  for(Method fun:methods){
                      System.out.println(fun);
                  }
                  //返回类或者超类的公有构造器
                  Constructor[]constructors=c.getConstructors();
                  System.out.println("类的公有构造器： ");
                  for(Constructor con:constructors){
                      System.out.println(con);
                  }


              }catch (ClassNotFoundException cne){
                  System.out.println("没有找到该类！！！");
              }

        }

        String name;
        public ReflectionTest(){
            ;
        }
        ReflectionTest(String  b){
            this.name=b;
            System.out.println("this is father class");
        }
        static void test(Integer x){

            System.out.println(x);
        }
}
//测试类
class rTest extends ReflectionTest{
    //Data field
    public int a;
    public String b;

    protected int c;
    protected String d;
    private int e;
    private String f;
    //default
    int g;
    String h;

    //methods
    public int A(int a){
        return a;
    }

    public void pf(){};
    private int B(int b){
        return b;
    }

    protected int C(int c){
        return c;
    }

    int D(int d){
        return d;
    }

    //constructer
   public rTest(){
        System.out.println("无参构造器");
    }
    public rTest(int a){
        this.a=a;
        System.out.println("有参公有构造器");
    }
    private rTest(int a,String b){
        this.a=a;
        this.b=b;
        System.out.println("有参私有构造器");
    }
}