菜鸟学Java（十五）——Java反射机制（二）

上一篇博文《菜鸟学编程（九）——Java反射机制（一）》里面，向大家介绍了什么是Java的反射机制，以及Java的反射机制有什么用。上一篇比较偏重理论，理论的东西给人讲出来总感觉虚无缥缈，还是结合一些实例比较形象具体。那么今天就结合更多的实例具体说说。

实例一：获得完整的类名

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());
    }

}

运行结果：

通过类本身获得对象
获得对象成功！

通过类对象获得类名
获得类名成功！
类名为：reflection.getclassname.GetClass Name

实例二：获得类的属性

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");
    }

}

运行结果：

该属性的名字为：id，该属性的类型为：java.lang.String

该属性的名字为：username，该属性的类型为：java.lang.String

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

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");
    }

}

运行结果：

该类实现的接口名字为：reflection.getinterfaces.Person

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

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();

    }

}

运行结果：

获得这个类的修饰符：public

第1个属性的修饰符为：private

第2个属性的修饰符为：

第3个属性的修饰符为：public static final

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

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");
    }

}

运行结果：

获得类reflection.getconstructor.GetConstructor所有的构造函数

遍历构造函数

这个构造函数的名字为：reflection.getconstructor.GetConstructor

通过构造函数获得这个类的名字为：class reflection.getconstructor.GetConstructor

参数 0 为 int

这个构造函数的名字为：reflection.getconstructor.GetConstructor

通过构造函数获得这个类的名字为：class reflection.getconstructor.GetConstructor

参数 0 为 int

参数 1 为 class java.lang.String

实例六：获得父类

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));

    }

}

运行结果：

获得父类的名字为：reflection.UserInfo

成功获得UserInfoMore的父类：reflection.UserInfo

实例七：获得类的方法

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");
    }

}

运行结果：

开始遍历类reflection.UserInfo.class

利用类的getDeclaredMethods获得类的所有方法

遍历获得的方法数组

开始遍历第1个方法

开始获取方法的变量类型

该方法的返回值类型为：class java.lang.String

开始遍历第2个方法

开始获取方法的变量类型

该方法的返回值类型为：class java.lang.Integer

开始遍历第3个方法

开始获取方法的变量类型

方法参数0类型为class java.lang.String

该方法的返回值类型为：void

开始遍历第4个方法

开始获取方法的变量类型

该方法的返回值类型为：class java.lang.String

开始遍历第5个方法

开始获取方法的变量类型

方法参数0类型为class java.lang.Integer

该方法的返回值类型为：void

开始遍历第6个方法

开始获取方法的变量类型

该方法的返回值类型为：class java.lang.String

开始遍历第7个方法

开始获取方法的变量类型

方法参数0类型为class java.lang.String

该方法的返回值类型为：void

这次实例不少吧，而且这些小例子都比较简单，相信大家都可以轻松秒懂。上面一些例子的代码并不是完整的，有些只有一些关键代码，如果想要完整的代码请戳下面的链接。最后祝大家学习愉快！

源码下载