注解和反射

注解声明

　　

Java反射机制

　　

　反射的作用

　　

　常用API

　　

public class GetClassInfo {
    public void test(String className) throws Exception{
        //获取Person类对象
        Class cls = Class.forName(className);
        
        //获取类在的包名
        Package pkg = cls.getPackage();
        System.out.println(cls.getSimpleName() + "定义在：" + pkg.getName() + "包中");
        System.out.println("--------------------------");
        
        //获取此对象所表示的实体（类、接口、基本类型或void）的超类Class
        //如果此对象是Object类、一个接口、一个基本类型或void，他的超类返回Null
        //如果此对象是一个数组类，返回表示Object类的Class对象
        Class superClass = cls.getSuperclass();
        System.out.println(cls.getSimpleName() + "的超类是：" + superClass.getName());
        System.out.println("--------------------------");
        
        //获取Person类所实现的接口
        //如果Person类没有实现任何的接口，返回一个长度为0的数组
        //如果Person类是一个基本类型或者是void，那么也返回一个长度为0的数组
        Class[] interfaces = cls.getInterfaces();
        System.out.println("所实现的数组有：");
        for(Class c : interfaces){
            System.out.println(c.getName());
        }
        System.out.println("---------------------------");
    }
    
    public static void main(String[] args) throws Exception{
        GetClassInfo getci = new GetClassInfo();
        getci.test("entity.Person");
    }
}

public class GetClassConstructorInfo{
    public void test1() throws Exception{
        Class cls = Class.forName("entity.Person");
        Object obj = cls.newInstance();
        System.out.println(obj.toString());
    }
    
    public void test2() throws Exception{
        Class cls = Class.forName("entity.Person");
        //获取类的构造函数
         Constructor[] consts = cls.getDeclaredConstructors(); 
         System.out.println("=============构造函数展示============");
         for(Constructor con : consts){
             Class[] params = con.getParameterTypes();
             if(params.length == 0){
                 System.out.println("此构造函数没有参数");
             }else{
                 System.out.println("此构造函数的参数列表为：");
                 for(int i=0; i<params.length; i++){
                     if(i!=0){
                         System.out.println(",");
                     }
                 }
             }
         }
    }
    
    public static void main(String[] args) throws Exception {
        GetClassConstructorInfo cons = new GetClassConstructorInfo();
        cons.test1();
    }
}

public class GetClassMethodsInfo {

    public static void main(String[] args) {
        GetClassMethodsInfo med = new GetClassMethodsInfo();
        // 展示方法调用
//        med.invokeSetter("entity.Person", "name", "java.lang.String", "张三");
        // 展示Person类中的方法信息
         med.showMethod();
    }
    
    public void invokeSetter(String clsName, String propName, String propType,
            Object propValue) {

        try {
            // 通过反射创建一个实例
            Class cls = Class.forName(clsName);
            Object obj = cls.newInstance();

            String firstLetter = propName.substring(0, 1).toUpperCase();
            String methodName = "set" + firstLetter + propName.substring(1);
            // 根据方法名和参数列表获取setter方法
            Method method = cls.getDeclaredMethod(methodName, Class.forName(propType));
            // 如果需要，可以通过setAccessable方法，设定为可以访问
            // method.setAccessible(true);
            // 调用方法并传参
            method.invoke(obj, propValue);

            System.out.println(obj);
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public void showMethod() {

        Method[] methods;
        try {
            // 获取Person中的所有方法，
            // 包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法,
            // 如果该类或接口不声明任何方法，或者此 Class 对象表示一个基本类型、一个数组类或 void，则此方法返回一个长度为 0
            // 的数组。
            methods = Class.forName("entity.Person")
                    .getDeclaredMethods();

            // 展示方法的一些信息
            System.out.println("===========方法展示==========");
            for (Method method : methods) {
                System.out.println("方法名：" + method.getName());
                System.out.println("返回值类型：" + method.getReturnType().getName());

                // 获取方法的参数列表
                Class[] params = method.getParameterTypes();
                if (params.length == 0) {
                    System.out.println("该方法没有参数");
                } else {
                    System.out.print("该方法的参数列表为：[");
                    for (int i = 0; i < params.length; i++) {
                        if (i != 0)
                            System.out.print(", ");
                        System.out.print(params[i].getName());
                    }
                    System.out.println("]");
                }

                // 获取方法所属的类或接口的Class对象
                Class declaringClass = method.getDeclaringClass();
                System.out.println("方法声明在：" + declaringClass.getName() + " 中");

                // 获取方法抛出的异常类型，即throws子句中声明的异常
                Class[] exceptions = method.getExceptionTypes();
                if (exceptions.length > 0) {
                    System.out.print("该方法抛出的异常有：[");
                    for (int i = 0; i < exceptions.length; i++) {
                        if (i != 0)
                            System.out.print(", ");
                        System.out.print(exceptions[i].getName());
                    }
                    System.out.println("]");
                }

                System.out.println("----------------------------");
            }
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

public class GetClassFieldsInfo {

    public static void main(String[] args) {
        GetClassFieldsInfo fieldTest = new GetClassFieldsInfo();
        // 查看字段信息
        fieldTest.showFields();
        // 直接访问字段
        fieldTest.accessField();
    }
    
    public void showFields() {

        Field[] fields;
        try {
            // 获取Person中的所有字段，
            // 包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段,
            // 如果该类或接口不声明任何字段，或者此 Class 对象表示一个基本类型、一个数组类或 void，则此方法返回一个长度为 0 的数组。
            fields = Class.forName("entity.Person").getDeclaredFields();

            // 展示字段的一些信息
            System.out.println("===========字段展示==========");
            for (Field field : fields) {
                System.out.println("字段名：" + field.getName());
                System.out.println("类型：" + field.getType().getName());
                System.out.println("----------------------------");
            }
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
    
    public void accessField() {

        // 本例演示通过反射操作Person的字段
        try {
            // 通过反射加载一个Person实例
            Class cls = Class.forName("entity.Person");
            Object obj = cls.newInstance();

            // 获取name字段
            Field name = cls.getDeclaredField("name");
            // name字段为private，这里已超出其访问范围，不能直接访问
            // 通过setAccessable方法，设定为可以访问
            name.setAccessible(true);
            // 先取值看一下
            System.out.println("赋值前的name：" + name.get(obj));
            // 为name字段赋值
            name.set(obj, "New Person");
            // 展示一下赋值效果
            System.out.println("赋值后的name：" + name.get(obj));
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}