java之反射详解

柔情只为你懂 2023-03-13 05:57 9阅读 0赞

**一、什么是反射**：能够分析类能力的程序称为反射

**二、反射的具体用途：**

*  通过反射获取类信息
 *  根据类信息生成实例（实例化功能）
 *  反射最终的目的就是拿到类的实例

\*\*三、反射的功能：\*\*反射类的信息，根据类的信息生成实例

**四、获得class类对象的三种方式**  
在程序运行期间，Java 运行时系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类。 虚拟机利用运行时类型信息选择相应的方法执行。  
然而，可以通过专门的 Java 类访问这些信息。保存这些信息的类被称为 Class, 这个名字很容易让人混淆。Object 类中的 getClass( ) 方法将会返回一个 Class 类型的实例。

*  类名.class（例如：Student.class）
 *  对象.getClass()
 *  Class.forName(“com.qcby.Student”)；字符串是一个全限定名 包名.类名的形式

String className = "com.qcby.Student";
    Class cl = Class.forName(className) ;

如果类名保存在字符串中， 并可在运行中改变， 就可以使用这个方法。当然， 这个方法只有在 className 是类名或接口名时才能够执行。 否则，forName 方法将抛出一个 checkedexception ( 已检查异常）。无论何时使用这个方法， 都应该提供一个异常处理器（exception handler) 。

String className = "com.qcby.Student";
    Class cl = null;
    try { 
    	cl = Class.forName(className);
    } catch (ClassNotFoundException e) { 
    	// TODO Auto-generated catch block
    	e.printStackTrace();
    }

**通过反射来创建对象（生成类的实例）**

//两个是等价的，即创建对象不一定非等通过new来实现。
    Student student = Student.class.newInstance();
    Student student1 = new Student();

通过反射只能拿到参数类型，拿不到参数名。  
可以拿到域的名字

public class Test { 
        private int age;
        @Override
        public String toString() { 
            return "Test{" +
                    "age=" + age +
                    '}';
        }
        public static void main(String[] args) { 
            Test test = new Test();
            try { 
                Field age = Test.class.getDeclaredField("age");
                //设置可访问非常重要
                age.setAccessible(true);
                age.set(test,20);
                System.out.println(test);
                System.out.println(age.get(test));
            } catch (NoSuchFieldException e) { 
                e.printStackTrace();
            } catch (IllegalAccessException e) { 
                e.printStackTrace();
            }
        }
    }

有人会有疑问，我们可以通过new来生成实例，**为什么还需要反射机制？**

> 通过new来创建对象比反射生成的实例要快，但是会有一种情况，**使得new没办法使用**。比如在使用框架的时候，容器的开发者不知道项目的开发者会写什么类，所以**无法用new的方法来给类进行实例化**，所以容器开发者也会写出一个类的模板来，当容器运行的时候\*\*，用反射的机制按照class.forName()这个方式获取类的信息然后在newInstance()进行实例化\*\*然后再运行，容器的开发者会把这个类的模板提供给项目开发者，项目开发者需要根据这个模板的规则来写对应的类，如果没有根据规则来写，也是不可以运行的。  
> 比如我们在使用tomcat开启动web项目的时候，tomcat开发者不知道项目中会有什么类，无法通过new来生成类的实例，所以tomcat容器写了一个类的模板，运行的时候利用反射获取类信息，然后生成对应的实例，然后执行调用方法。tomcat中是依靠注解来分辨哪个是需要实例化的servlet类信息

附：简单类加载机制![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQxOTIwMDY1_size_16_color_FFFFFF_t_70]  
当类加载的时候出现静态的方法和属性（静态域），他会在我们的方法区内单独开辟空间  
静态的成员或者方法会伴随着类加载到方法区  
非静态的没有自己的空间，不可直接使用

**反射机制允许你调用任意方法：**  
1、我们通过第一个try-catch可以看到即使是对象中的私有属性通过反射也是可以访问到的，前提是设置可访问的属性。  
2、通过第二个try-catch的应用我们便实现了利用反射机制中的invoke方法来调用对象中的方法，也就是我们通常所说的代理，从这里我们可以看到，反射和代理是在一起使用的。

public class RefelectionTest { 
        public static void main(String[] args) { 
            String name;
            if (args.length>0 ) name = args[0];
            else { 
                Scanner in = new Scanner(System.in);
                System.out.println("Enter class name(e.g.java.util.Date):");
                name = in.next();
            }
            try { 
                Class cl = Class.forName(name);
                Class supercl = cl.getSuperclass();
                String modifiers = Modifier.toString(cl.getModifiers());
                if(modifiers.length()>0){ 
                    System.out.print(modifiers+" ");
                }
                System.out.print("class"+name);
                if (supercl!=null && supercl!=Object.class) System.out.print("extends"+supercl.getName());
                System.out.print("\n{\n");
                printConstructors(cl);
                System.out.println();
                printMethods(cl);
                System.out.println();
                printFields(cl);
                System.out.println("}");
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            }
            System.exit(0);
        }
    
    
    
        private static void printConstructors(Class cl) { 
            Constructor[] constructors = cl.getDeclaredConstructors();
            for (Constructor c:constructors) { 
                String name = c.getName();
                System.out.print(" ");
                String modifiers = Modifier.toString(c.getModifiers());
                if (modifiers.length()>0) System.out.print(modifiers+" ");
                System.out.printf(name+"(");
    
                Class[] paramTypes = c.getParameterTypes();
                for (int i = 0; i < paramTypes.length; i++) { 
                    if (i>0) System.out.print(",");
                    System.out.printf(paramTypes[i].getName());
                }
                System.out.println(");");
            }
        }
        private static void printMethods(Class cl) { 
            Method[] methods = cl.getDeclaredMethods();
            for (Method m:methods) { 
                Class retType = m.getReturnType();
                String name = m.getName();
                System.out.printf(" ");
                String modifiers = Modifier.toString(m.getModifiers());
                if (modifiers.length()>0) System.out.printf(modifiers+" ");
                System.out.printf(retType.getName()+" "+name+"(");
    
                Class[] paramTypes = m.getParameterTypes();
                for (int i = 0; i < paramTypes.length; i++) { 
                    if (i>0) System.out.print(",");
                    System.out.printf(paramTypes[i].getName());
                }
                System.out.println(");");
            }
        }
        private static void printFields(Class cl) { 
            Field[] fields =cl.getDeclaredFields();
            for (Field f:fields) { 
                Class type = f.getType();
                String name = f.getName();
                System.out.printf(" ");
                String modifiers = Modifier.toString(f.getModifiers());
                if (modifiers.length()>0) System.out.printf(modifiers+" ");
                System.out.println(type.getName() + " "+ name +";");
            }
        }
    }

**补充：**

> 反射除了这些，在我们的Spring框架中的应用是很多很多的，比如说ioc和aop，springMVC原理等等都用到了反射机制，反射在框架中应用很广，这是一个非常重要的知识点，对于我们学习web是必须要掌握的。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQxOTIwMDY1_size_16_color_FFFFFF_t_70]: /images/20230312/6597d85f090d4ab49d774362162e24e2.png