Java学习笔记（47）——Java反射

一、概述

Java的反射和C#的反射也是一样的道理：

在Java中的反射机制是指在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法，这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

与反射有关的所有接口以及类都在java.lang.reflect包里:

Demo：

实例一：获得完整的类名

package reflection.getclassname;

//获得完整的类名
public class GetClassName {

    public String getNameByClass() {
        
        String name = "";
        System.out.println("通过类本身获得对象");
        Class UserClass = this.getClass();
        System.out.println("获得对象成功！\n");
        
        System.out.println("通过类对象获得类名");
        name = UserClass.getName();
        System.out.println("获得类名成功！");
        return name;
    }
    public static void main(String[] args) {
        
        GetClassName gcn = new GetClassName();
        System.out.println("类名为："+gcn.getNameByClass());
    }

}

实例二：获得类的属性

package reflection.getfields;

import java.lang.reflect.Field;

//获得类的属性
public class GetFields {

    public static void getFieldNames(String className) {
        
        try {
            //获得类名
            Class c = Class.forName(className);
            //获得所有属性
            Field[] fds = c.getFields();
            
            for (int i=0; i<fds.length; i++)
            {
                String fn = fds[i].getName();
                Class tc = fds[i].getType();
                String ft = tc.getName();
                System.out.println("该属性的名字为："+fn+"，该属性的类型为："+ft);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        GetFields.getFieldNames("reflection.getfields.FieldInfo");
    }

}

实例三：获得类实现的接口

package reflection.getinterfaces;

//获得类实现的接口
public class GetInterfaces {

    public static void getInterfaces(String className) {
        try {
            //取得类
            Class cl = Class.forName(className);
            Class[] ifs = cl.getInterfaces();
            for (int i = 0; i<ifs.length;i++)
            {
                String IName = ifs[i].getName();
                System.out.println("该类实现的接口名字为："+IName);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        GetInterfaces.getInterfaces("reflection.getinterfaces.Student");
    }

}

实例四：获得类及其属性的修饰符

package reflection.getmodifiers;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

import reflection.UserInfo;

//获得类及其属性的修饰符
public class GetModifiers {

    private String username = "liu shui jing";
    float f = Float.parseFloat("1.000");
    public static final int i = 37;
    
    //获得类的修饰符
    public static String useModifiers(UserInfo ui) {
        
        Class uiClass = ui.getClass();
        int m = uiClass.getModifiers();
        return Modifier.toString(m);
        
    }
    
    //获得本类属性的修饰符
    public void checkThisClassModifiers() {
        
        Class tc = this.getClass();        
        Field fl[] = tc.getDeclaredFields();
    
        for(int i=0;i<fl.length;i++)
        {
            System.out.println("第"+(i+1)+"个属性的修饰符为："+Modifier.toString(fl[i].getModifiers()));
        }
        
    }
    public static void main(String[] args) {
        
        //获得类的修饰符
        UserInfo ui =new UserInfo();
        System.out.println("获得这个类的修饰符："+GetModifiers.useModifiers(ui)+"\n");
        
        //获得本类属性的修饰符
        GetModifiers gm = new GetModifiers();
        gm.checkThisClassModifiers();
        
    }

}

实例五：获得类的构造函数

package reflection.getconstructor;

import java.lang.reflect.Constructor;

//获得类的构造函数
public class GetConstructor {

    //构造函数一
    GetConstructor(int a) {
        
    }
    
    //构造函数二
    GetConstructor(int a, String b) {
        
    }
    
    public static void getConstructorInfo(String className) {
        try {
            //获得类的对象
            Class cl =Class.forName(className);
            System.out.println("获得类"+className+"所有的构造函数");
            Constructor ctorlist[] = cl.getDeclaredConstructors();
            System.out.println("遍历构造函数\n");
            for(int i =0 ; i<ctorlist.length; i++)
            {
                Constructor con = ctorlist[i];
                System.out.println("这个构造函数的名字为："+con.getName());
                System.out.println("通过构造函数获得这个类的名字为："+con.getDeclaringClass());
                
                Class cp[] = con.getParameterTypes();
                for (int j=0; j<cp.length; j++)
                {
                    System.out.println("参数 "+j+" 为 "+cp[j]+"\n");
                }
            }
        }catch (Exception e) {
                System.err.println(e);            
        }
    }
    public static void main(String[] args) {
        GetConstructor.getConstructorInfo("reflection.getconstructor.GetConstructor");
    }

}

实例六：获得父类 

package reflection.getparentclass;

//获得父类
public class GetParentClass {

    public static String getParentClass(UserInfoMore uim) {
        
        //获得父类
        Class uimc = uim.getClass().getSuperclass();
        System.out.println("获得父类的名字为："+uimc.getName());
        return uimc.getName();
        
    }
    
    public static void searchParentClass() {
        
    }
    
    public static void main(String[] args) {
        
        UserInfoMore uim = new UserInfoMore();
        System.out.println("成功获得UserInfoMore的父类："+GetParentClass.getParentClass(uim));
        
    }

}

实例七：获得类的方法 

package reflection.getmethod;

import java.lang.reflect.Method;

//获得类的方法
public class GetMethod {

    public static void getMethods(String className) {
        try {
            System.out.println("开始遍历类"+className+".class");
            //获得类名
            Class cls = Class.forName(className);
            //利用方法获得所有该类的方法
            System.out.println("利用类的getDeclaredMethods获得类的所有方法");
            Method ml[] =cls.getDeclaredMethods();
            System.out.println("遍历获得的方法数组\n");
            for (int i = 0 ;i<ml.length;i++)
            {
                System.out.println("开始遍历第"+(i+1)+"个方法");
                Method m = ml[i];
                System.out.println("开始获取方法的变量类型");
                Class ptype[] = m.getParameterTypes();
                for (int j=0; j<ptype.length; j++)
                {
                    System.out.println("方法参数"+j+"类型为"+ptype[j]);
                }
                Class gEx[] = m.getExceptionTypes();
                for (int j=0 ; j<gEx.length; j++)
                {
                    System.out.println("异常"+j+"为"+ gEx[j]);
                }
                
                System.out.println("该方法的返回值类型为："+m.getReturnType()+"\n");
                
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        GetMethod.getMethods("reflection.UserInfo");
    }

}