简单的Java的反射

Java的反射

什么是Java的反射？

在运行期间得到类的各种信息，包括变量、构造器、方法等并对其惊醒操作。这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制

废话不多说，直接上

1. 首先创建两个测试类

    public abstract class FatherObject implements Runnable {
        public void doSomething() {
        System.out.println("doSomething......");
        }
    }

    public class ExampleObject extends FatherObject {
        public int age = 11;
        public String name = "LGZ";
        private Integer score = 59;

        public void printName() {
            System.out.println(name);
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Integer getScore() {
            return score;
        }

        public void setScore(Integer score) {
            this.score = score;
        }

        public ExampleObject() {

        }

        public ExampleObject(String name) {

        }

        public ExampleObject(int age, Integer score) {

        }

        @Override
        public void doSomething() {
            super.doSomething();
        }

        @Override
        public void run() {
            System.out.println("run......");
        }
    }

2.测试

        public class Test {

            public static void main(String[] args) {
                testReflect(new Object());
            }
            private static void testReflect(Object obj){
                Class exampleObj;
                try {
                    //在JDK中，使用Class对象来保存类的信息，有两种方式
                    exampleObj = Class.forName("com.kcj.test.ExampleObject");
                    //exampleObj = ExampleObject.class;
                    //得到类名
                    String fullClassName = exampleObj.getName();
                    String simpleClassName = exampleObj.getSimpleName();
                    System.out.println(fullClassName);
                    System.out.println(simpleClassName);
                    //得到包信息
                    Package aPackage = exampleObj.getPackage();
                    System.out.println(aPackage);

                    //得到父类
                    Class superClass = exampleObj.getSuperclass();
                    System.out.println(superClass.getSimpleName());
                    System.out.println("父类是不是抽象类 " + Modifier.isAbstract(superClass.getModifiers()));
                    /*
                    Modifier.isAbstract(int modifiers);
                    Modifier.isFinal(int modifiers);
                    Modifier.isInterface(int modifiers);
                    Modifier.isNative(int modifiers);
                    Modifier.isPrivate(int modifiers);
                    Modifier.isProtected(int modifiers);
                    Modifier.isPublic(int modifiers);
                    Modifier.isStatic(int modifiers);
                    Modifier.isStrict(int modifiers);
                    Modifier.isSynchronized(int modifiers);
                    Modifier.isTransient(int modifiers);
                    Modifier.isVolatile(int modifiers);
                    */
                    //得到接口
                    Class[] classes = superClass.getInterfaces();
                    System.out.println("父类的接口" + classes[0]);
                    //构造器
                    Constructor[] constructors = exampleObj.getConstructors();
                    for (Constructor constructor : constructors){
                        System.out.println(constructor.toString());
                        Class[] parameterTypes = constructor.getParameterTypes();
                        System.out.println("构造器参数如下========================");
                        for (Class clz : parameterTypes){
                            System.out.println("参数类型 " + clz.toString());
                        }
                    }
                    //事先知道要访问的构造方法的参数类型，可以利用如下方法获取指定的构造方法
                    Constructor constructor = exampleObj.getConstructor(int.class, Integer.class);
                    System.out.println(constructor.toString());
                    //根据构造器的各种信息，动态创建一个对象
                    Object object = constructor.newInstance(1,100);
                    System.out.println(object.toString());

                    //得到所有public的变量
                    Field[] fields = exampleObj.getFields();
                    for (Field field : fields){
                        System.out.println("变量为： " + field.toString());
                    }

                    //指定一个参数名，然后得到指定的变量
                    Field field = exampleObj.getField("age");
                    System.out.println("变量为:" + field.toString());

                    Constructor constructor1 = exampleObj.getConstructor(String.class);
                    ExampleObject object1 = ((ExampleObject) constructor1.newInstance("byhieg"));
                    System.out.println("原先的age是 " + object1.age);
                    field.set(object1, 10);
                    System.out.println("更改之后的age是" + object1.age);

                    //输出类的public方法
                    Method[] methods = exampleObj.getMethods();
                    for (Method method : methods){
                        System.out.println("method = "+ method.getName());
                    }

                    //根据方法名和对应的参数得到一个方法
                    Method method = exampleObj.getMethod("setAge",int.class);
                    System.out.println(method.getName());
                    for (Class clz : method.getParameterTypes()){
                        System.out.println("方法的参数" + clz.getName());
                    }

                    //得到方法返回的数据类型
                    System.out.println("方法返回的数据类型 = "+method.getReturnType().getName());

                    //通过invoke调用得到的方法
                    method.invoke(exampleObj.newInstance(),1);

                } catch (Exception e) {
                    e.printStackTrace();
                }


            }
    }