Java反射机制

一、什么是反射机制 
    简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。 那么就可以通过反射机制来获得类的所有信息。 

二、哪里用到反射机制 

    有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码，Class.forName("com.mysql.jdbc.Driver")但是那时候只知道那行代码是生成驱动对象实例，并不知道它的具体含义。听了反射机制这节课后，才知道，原来这就是反射，现在很多开框架都用到反射机制，hibernate、struts都是用反射机制实现的。

三、反射机制的优点与缺点 
     为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，静态编译：在编译时确定类型，绑定对象,即通过。动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。 
四、利用反射机制能获得什么信息 
      一句话，类中有什么信息，它就可以获得什么信息，不过前提是得知道类的名字，要不就没有后文了。首先得根据传入的类的全名来创建Class对象。

//第一种方法
Class forName = Class.forName("cn.zhaoqiang.reflection.UserInfo");
//第二种方法
//Class clazz =UserInfo.class;
//第三种方法
//Class clazz = new UserInfo().getClass();

//1.名和类名同时获取
    public static void getPackageAndClassName(Class clazz){
        Package pack = clazz.getPackage();
        System.out.println("获取类名与包名");
        System.out.println("类名为："+clazz.getSimpleName());
        System.out.println("包名为："+pack.getName());
        System.out.println("类的全名为："+clazz.getName());
        
    }

//2.获取类中的字段
    public static void getClassFields(Class clazz) throws Exception{
    //getDeclaredFields() 只能获取当前类的字段
        Field[] declaredFields = clazz.getDeclaredFields();
        //不知道类名的情况下也可以创建类的对象
        Object obj = clazz.newInstance();
        for (Field field : declaredFields) {
            field.setAccessible(true);
            System.out.println("获取字段名称："+field.getName()); 
            //取出字段保存的值
            System.out.println("获取字段中保存的值："+field.get(obj));
        }
            Field field = clazz.getDeclaredField("age");
            field.setAccessible(true);
            //给字段赋值
            field.set(obj, 12);
           System.out.println("赋值成功！值为:"+ field.get(obj));
           //获取age字段的数据类型
            Class<?> type = field.getType();
           System.out.println("age字段的数据类型是:"+type.getName());
           //获取访问修饰符
           int code = field.getModifiers();
           System.out.println("该字段的访问修饰符是:"+Modifier.toString(code));
}

//3:获取类中的方法
            public static void getClassMethod(Class clazz) throws Exception{
                   //可以获取从父类继承过来的方法
                    Method[] methods = clazz.getMethods();
                    
                    System.out.println("方法的个数："+methods.length);
                    for (Method method : methods) {
                        System.out.println("类和父类的方法有:"+method.getName());
                    }
                    System.out.println("--------------------------------------------------------");
                    //获取当前类的方法
                    Method[] declaredMethods = clazz.getDeclaredMethods();
                    for (Method method : declaredMethods) {
                           System.out.println("该类的方法有:"+method.getName());
                    }
                    //获取单个方法
                    Method method = clazz.getDeclaredMethod("say",String.class);
                    //获取方法的返回值
                    Class  clazzs = method.getReturnType();
                    System.out.println("该方法的返回值是"+clazzs.getName());
                    //获取方法的形参类型
                    Class[] params = method.getParameterTypes();
                    for (Class class1 : params) {
                        System.out.println("形参有:"+class1.getName());
                    }
                    //不知道类名的情况下也可以创建类的对象
                    Object obj = clazz.newInstance();
                    //invoke让method对象执行
                    Object obj1= method.invoke(obj, "我是狗");
                    System.out.println("方法执行后的结果是:"+obj1);
            }

//4:获取构造
            public static void getClassConstructor(Class<?> clazz) throws Exception{
                //获取所有构造器
                  Constructor[] constructors = clazz.getConstructors();
                  for (Constructor<?> constructor : constructors) {
                        System.out.println(constructor.getName());
                  }
                  //获取单个构造器
                  Constructor<?> constructor = clazz.getConstructor(String.class,int.class);
                  //执行构造器,返回类的实例
                  Object obj = constructor.newInstance("呵呵",12);
            }

 

//5：获取注解
             public static void getClassAnnotion(Class clazz) throws Exception{
                       @SuppressWarnings("unchecked")
                    Method method = clazz.getDeclaredMethod("getAge");
                       java.lang.annotation.Annotation[] annotations = method.getAnnotations();
                       for (java.lang.annotation.Annotation annotation : annotations) {
                          System.out.println("该方法的注解有："+annotation.toString());
                    }
             }

//6:获取类的父类以及实现的接口
        public static void getSuperClassAndInterface(Class clazz){
            System.out.println("该类的父类是:"+clazz.getSuperclass().getName());
            System.out.println("该类实现的接口有:");
            Class[] interfaces = clazz.getInterfaces();
            for (Class item : interfaces) {
                System.out.println("接口名称为："+item.getName());
            }
            
        }

 

--常见方法总结:
clazz.getPackage() 返回值是Package对象，获取包
clazz.getName() 返回值String,获取完整类名
clazz.getSimpleName() 返回值String 获取完整类名
clazz.getFields/getField(String 字段名) 返回值 Field获取类中的字段(包括父类的)
clazz.getDeclaredFields/getDeclaredField(String 字段名) 返回值 Field 仅仅获取类的字段
clazz.getSuperclass() 返回值Class 获取父类
clazz.getInterfaces() 返回Class[] 获取实现的接口
clazz.getMethods/getMethod(String 方法名，Class 形参类型) 获取方法（包括父类的方法）
clazz.getDeclaredMethods/getDeclaredMethod(String 方法名，Class 形参类型) 获取当前类的方法，不包括父类
method.invoke(Object obj) 执行方法 返回值Object
method.getReturnType() 返回值Class 获取方法的返回值类型
method.getParameterTypes() 返回值Class[] 获取方法的形参数组
field.get(Object) 获取字段的值 返回值Object
field.set(Object,value) 给字段赋值
field.getType() 返回值Class 获取字段类型
field.getModifiers() 获取字段的访问修饰符码 十六进制
Modifier.toString(int) 将code返回成真实的修饰符 private
clazz.newInstance():创建类的实例
clazz.getConstructors(): 返回值Constructor[] 获取类中的所有构造
clazz.getConstructor(Class) 获取单个构造器 返回值Constructor
Constructor.newInstance(Object) 运行构造器 返回值是类的实例
clazz.getAnnotions() Annotion[] 获取所有注解

       总的来说，java反射机制是一个很好用的东西，用它可以解决很多死的东西，因为反射机制的灵活行很大，有了他，我们就不要花太多的时间来写操做数据库的代码了，而是方法更多的时间在项目的逻辑功能上，这个可以很大的减少开发时间，而且代码的可读性好。先在的很多开源框架都是才用的反射机制，它只要配置文件，然后按规则来调用他的方法就可以了。