Java反射

一、利用反射获取类的能力(利用反射检查类的结构)

先来看看代码

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        
        reflect("java.lang.Double");
    }
    
    /*
     * 反射
     */
    public static void reflect(String className){
        
        try {
            //根据类的完整名称获取到类的实例
            Class cl = Class.forName(className);
            Class supercl = cl.getSuperclass(); //获取父类
            String modifiers = Modifier.toString(cl.getModifiers());
            if(modifiers.length()>0){
                System.out.print(modifiers+" ");
            }
            System.out.print("class " + className);
            if(supercl != null && supercl != Object.class){
                System.out.print(" extends " + supercl.getName());
            }
            System.out.print("
{
");
            printConstructors(cl);  //打印构造方法
            System.out.println();
            printMethods(cl);   //打印类的所有方法
            System.out.println();
            printFields(cl);   //这里打印类的字段 
            System.out.println("}");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    /*
     * 打印某个class的全部的构造函数
     */
    public static void printConstructors(Class cl){
        //获取当前class的全部构造方法
        Constructor[] constructors = cl.getDeclaredConstructors();
        
        //遍历每一个构造方法
        for(Constructor c:constructors){
            //获取构造方法的方法名称
            String name = c.getName();
            System.out.print("  ");
            String modifiers = Modifier.toString(c.getModifiers());
            
            if(modifiers.length()>0){
                //打印修饰符 public 
                System.out.print(modifiers + " ");
            }
            //打印构造方法名称
            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(");");
        }
    }
    
    /*
     * 打印类的所有方法
     * @param cl
     */
    public static void printMethods(Class cl){
        //获取方法的集合
        Method[] methods = cl.getDeclaredMethods();
        
        //遍历方法
        for(Method m : methods){
            
            //获取方法的返回类型
            Class retType = m.getReturnType();
            //获取方法名称
            String name = m.getName();
            System.out.print("  ");
            
            //获取方法修饰符
            String modifiers = Modifier.toString(m.getModifiers());
            if(modifiers.length()>0){
                //打印方法的修饰符
                System.out.print(modifiers+" ");
            }
            //打印返回类型和方法名称
            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(");");
            
        }
    } 
    
    /*
     * 打印所有字段 
     * @param cl
     */
    public static void printFields(Class cl){
        //获取类的所有全局变量字段
        Field[] fields = cl.getDeclaredFields();
        
        for(Field f : fields){
            //获取字段的类型 例如 ：int ，String  等
            Class type = f.getType();
            //获取字段名称
            String name = f.getName();
            System.out.print("  ");
            //获取字段的修饰符  例如：public 或者private或者public static final等
            String modifiers = Modifier.toString(f.getModifiers());
            if(modifiers.length()>0){
                //打印字段的修饰符
                System.out.print(modifiers +" ");
            }
            //打印字段的数据类型和字段名称
            System.out.println(type.getName() + " " + name + ";");
        }
    }
    
}

打印出的结果是：

public final class java.lang.Double extends java.lang.Number
{
  //构造方法
  public java.lang.Double(double);
  public java.lang.Double(java.lang.String);

  //类的方法
  public boolean equals(java.lang.Object);
  public static java.lang.String toString(double);
  public java.lang.String toString();
  public int hashCode();
  public static int hashCode(double);
  public static double min(double, double);
  public static double max(double, double);
  public static native long doubleToRawLongBits(double);
  public static long doubleToLongBits(double);
  public static native double longBitsToDouble(long);
  public volatile int compareTo(java.lang.Object);
  public int compareTo(java.lang.Double);
  public byte byteValue();
  public short shortValue();
  public int intValue();
  public long longValue();
  public float floatValue();
  public double doubleValue();
  public static java.lang.Double valueOf(java.lang.String);
  public static java.lang.Double valueOf(double);
  public static java.lang.String toHexString(double);
  public static int compare(double, double);
  public static boolean isNaN(double);
  public boolean isNaN();
  public static boolean isFinite(double);
  public static boolean isInfinite(double);
  public boolean isInfinite();
  public static double sum(double, double);
  public static double parseDouble(java.lang.String);

  //类的字段
  public static final double POSITIVE_INFINITY;
  public static final double NEGATIVE_INFINITY;
  public static final double NaN;
  public static final double MAX_VALUE;
  public static final double MIN_NORMAL;
  public static final double MIN_VALUE;
  public static final int MAX_EXPONENT;
  public static final int MIN_EXPONENT;
  public static final int SIZE;
  public static final int BYTES;
  public static final java.lang.Class TYPE;
  private final double value;
  private static final long serialVersionUID;
}

 在java.lang.reflect包（反射包） 中有三个类Field 、Method 和Constructor 分别用于描述类的域、方法、构造器。

从上面的代码中我们可以分析

我们先从类开始分析

上面我们传入了java.lang.Double

　　Class  

Class cl = Class.forName(String className);   //获取类    

cl.getSuperclass(); //获取父类  

cl.getModifiters(); //获取类的修饰符

cl.getDeclaredConstructors(); //获取类中所有的构造方法

cl.getDeclaredMethods(); //获取类中所有的方法

cl.getDeclaredFields();  //获取类中所有的字段

　　Constructors类

constructors类：public java.lang.Double(double);取上面输出结果的其中一条用来举例说明

constructors.getModifiters(); //获取构造方法的修饰符采用这种方式获取Modifier.toString(c.getModifiers()); ：public 

constructors.getName(); //获取构造方法名 java.lang.Doublie

constructors.getParameterTypes(); //获取所有参数数据类型  double

　　Method类

method类:  public boolean equals(java.lang.Object); //理由同上

method.getModifiters(); //获取方法的修饰符采用这种方式获取Modifier.toString(m.getModifiers());  ：public

method.getReturnType(); //获取方法的返回类型 ：boolean

method.getName(); //获取方法名 ：equals

method.getParameterTypes(); //获取所有参数的数据类型  返回的是数组 ：java.lang.Object

      Field类

Field类：public static final double MAX_VALUE; 是类的字段中的一条我们用来分析

Field.getName(); //获取字段的名称： MAX_VALUE

Field.getType();  //获取字段的数据类型 ：double

Field.getModifiers(); //获取字段的修饰符采用这种方式获取Modifier.toString(f.getModifiers()); ：public static final  

仔细看上面的三个类有共同名称的方法，归纳以下还是便于记忆的，那么就先介绍到这儿了。