java反射基础

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

 

反射的主要方法

方法/属性	解释
getDeclaredMethods()	获取所有的方法
getReturnType()	获得方法的放回类型
getParameterTypes()	获得方法的传入参数类型
getDeclaredMethod("方法名",参数类型.class,……)	获得特定的方法
getDeclaredConstructors()	获取所有的构造方法
getDeclaredConstructor(参数类型.class,……)	获取特定的构造方法
getSuperclass()	获取某类的父类
getInterfaces()	取某类实现的接口
getDeclaredField()	获取声明的指定属性
getDeclaredFields()	获取声明的所有属性
getField()	获取指定属性
getFields()	获取所有属性
field.get(clazz)	获取类属性
field.set(clazz,property);	设置类属性

反射相关的类
java.lang.Class;                
java.lang.reflect.Constructor; 
java.lang.reflect.Field;        
java.lang.reflect.Method;
java.lang.reflect.Modifier;

反射访问类的属性
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.simple.dec.advance.basic.basic1.SonClazz");
            Field field = clazz.getDeclaredField("sonPwd");
            field.setAccessible(true);
            Object result = field.get(this);
            ZLog.zzE(result);
            field.set(this, "Java反射机制");
            result = field.get(this);
            ZLog.zzE(result);
        } catch (Exception e) {
            e.printStackTrace();
        }

反射访问类的方法
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.simple.dec.advance.basic.basic1.SonClazz");
            Method method = clazz.getMethod("getSonPwd");
//            method.invoke(clazz.newInstance());
            Object result = method.invoke(this);
            ZLog.zzE(result);   // 不带参数
            method = clazz.getMethod("getSonEmail");
            result = method.invoke(this);
            ZLog.zzE(result);   // 带参数，访问私有方法
            method = clazz.getDeclaredMethod("getSum",int.class,String.class);
            method.setAccessible(true);
            result = method.invoke(this,100,"isSon...");
            ZLog.zzE(result);
            method = clazz.getMethod("getSum",int.class,String.class);
            result = method.invoke(this,100,"isSon...");
            ZLog.zzE(result);
        } catch (Exception e) {
            e.printStackTrace();
        }

参考：

     Java反射机制详解

     Java 反射

     JAVA反射与注解

     JAVA中的反射机制

备用代码

    /**
     * 调用子类的某个方法
     *  无法访问私有方法
     */
    private void getSonMethod(){
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.simple.dec.advance.basic.basic1.SonClazz");
            Method method = clazz.getMethod("getSonPwd");
//            method.invoke(clazz.newInstance());
            Object result = method.invoke(this);
            ZLog.zzE(result);   // 不带参数
            method = clazz.getMethod("getSonEmail");
            result = method.invoke(this);
            ZLog.zzE(result);   // 带参数，访问私有方法
            method = clazz.getDeclaredMethod("getSum",int.class,String.class);
            method.setAccessible(true);
            result = method.invoke(this,100,"isSon...");
            ZLog.zzE(result);
            method = clazz.getMethod("getSum",int.class,String.class);
            result = method.invoke(this,100,"isSon...");
            ZLog.zzE(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取子类所有方法
     */
    private void getSonMethodAll(){
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.simple.dec.advance.basic.basic1.SonClazz");
            Method method[] = clazz.getMethods();
            for (int i = 0; i < method.length; ++i) {
                Class<?> returnType = method[i].getReturnType();
                Class<?> para[] = method[i].getParameterTypes();
                int temp = method[i].getModifiers();
                System.out.print(Modifier.toString(temp) + " ");
                System.out.print(returnType.getName() + "  ");
                System.out.print(method[i].getName() + " ");
                System.out.print("(");
                for (int j = 0; j < para.length; ++j) {
                    System.out.print(para[j].getName() + " " + "arg" + j);
                    if (j < para.length - 1) {
                        System.out.print(",");
                    }
                }
                Class<?> exce[] = method[i].getExceptionTypes();
                if (exce.length > 0) {
                    System.out.print(") throws ");
                    for (int k = 0; k < exce.length; ++k) {
                        System.out.print(exce[k].getName() + " ");
                        if (k < exce.length - 1) {
                            System.out.print(",");
                        }
                    }
                } else {
                    System.out.print(")");
                }
                System.out.println();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        ZLog.zzE("");
    }

    /**
     * 调用子类的某个属性
     *  可以直接访问private属性
     */
    private void getSonProperty(){
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.simple.dec.advance.basic.basic1.SonClazz");
            Field field = clazz.getDeclaredField("sonPwd");
            field.setAccessible(true);
            Object result = field.get(this);
            ZLog.zzE(result);
            field.set(this, "Java反射机制");
            result = field.get(this);
            ZLog.zzE(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取子类所有属性
     */
    private void getSonPropertyAll(){
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.simple.dec.advance.basic.basic1.SonClazz");
            System.out.println("===============本类属性===============");
            // 取得本类的全部属性
            Field[] field = clazz.getDeclaredFields();
            for (int i = 0; i < field.length; i++) {
                // 权限修饰符
                int mo = field[i].getModifiers();
                String priv = Modifier.toString(mo);
                // 属性类型
                Class<?> type = field[i].getType();
                System.out.println(priv + " " + type.getName() + " " + field[i].getName() + ";");
            }

            System.out.println("==========实现的接口或者父类的属性==========");
            // 取得实现的接口或者父类的属性
            Field[] filed1 = clazz.getFields();
            for (int j = 0; j < filed1.length; j++) {
                // 权限修饰符
                int mo = filed1[j].getModifiers();
                String priv = Modifier.toString(mo);
                // 属性类型
                Class<?> type = filed1[j].getType();
                System.out.println(priv + " " + type.getName() + " " + filed1[j].getName() + ";");
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }