java-反射

什么是反射

  • Reflection(反射)是被视为动态语言的关键,反射机制允许程序在执行期
    借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内
    部属性及方法
  • 反射可以调用类的私有结构:私有的构造器、属性和方法。

Class类

  • Class类是反射的源头
  • 类的加载过程

程序经过javac.exe命令以后,会生成一个或多个字节码文件(.class结尾)。
使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件
加载到内存中。此过程就称为类的加载。

  • 加载到内存中的类,我们就称为运行时类,此运行时类,就作为Class的一个实例。

获取Class对象的方式

  1. 调用运行时类的属性:.class
        //方式一:调用运行时类的属性:.class
        Class<Movie> clazz = Movie.class;
        System.out.println(clazz);
  1. 通过运行时类的对象,调用getClass()
        //方式二:通过运行时类的对象,调用getClass()
        Movie movie = new Movie();
        Class<? extends Movie> clazz1 = movie.getClass();
        System.out.println(clazz1);
  1. 调用Class的静态方法:forName(String classPath)
        //方式三:调用Class的静态方法:forName(String classPath)
        try {
            Class<?> clazz2 = Class.forName("com.refine.day04.java.Movie");
            System.out.println(clazz2);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
  1. 使用类的加载器:ClassLoader
        //方式四:使用类的加载器:ClassLoader
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        try {
            Class<?> clazz3 = classLoader.loadClass("com.refine.day04.java.Movie");
            System.out.println(clazz3);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
  • 哪些类型可以有Class对象

class:外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类
interface:接口
[]:数组
enum:枚举
annotation:注解@interface
primitive type:基本数据类型
void

类的加载

  1. 类的加载(Load)
    将类的class文件读入内存,并为之创建一个java.lang.Class对象。此过程由类加载器完成;
  2. 类的链接(Link)
    将类的二进制数据合并到JRE中
  3. 类的初始化(Initialize)
    JVM负责对类对象初始化

类加载器:ClassLoader

  1. 类加载的作用
    将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口。
  2. 类加载器分类
  • 引导类加载器:负责java核心平台库,该加载器无法直接获取
  • 扩展类加载器
  • 系统类加载器

使用ClassLoader加载配置文件

        Properties properties=new Properties();
        //读取配置文件的方式二:使用ClassLoader
        //配置文件默认识别为:当前module的src下
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
        try {
            properties.load(is);
            Object name = properties.get("name");
            Object password = properties.get("password");
            System.out.println(name+"\t"+password);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally{
            if( is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

创建运行时对象

  • newInstance():此方法可以创建运行时对象
  • 运行时类必须提供空参的构造器;
  • 空参的构造器的访问权限修饰符需要设置为默认、protected、public,不能设置为private。通常,设置为public。
        Class<Movie> clazz = Movie.class;
        try {
            Movie movie = clazz.newInstance();
            System.out.println(movie);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }

反射的动态性

  • Class.forName():编译期间无法确定创建何种对象,只有在运行期间才可以确定,体现了反射的动态性。
    @Test
    public void test() {
        int num = new Random().nextInt(3);//0,1,2
        String classPath = "";
        switch (num) {
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.refine.day04.java.Movie";
                break;
        }
        Object obj = null;
        try {
            obj = getInstance(classPath);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println(obj);
    }
    
    public Object getInstance(String classPath) throws Exception{
        Class clazz = Class.forName(classPath);
        return clazz.newInstance();
    }

获取运行时类的完整结构

获取属性结构

  • getFields():获取当前运行时类及其父类中声明为public访问权限的属性
  • getDeclaredFields():当前运行时类中声明的所有属性
    @Test
    public void test1(){
        Class<Teacher> clazz = Teacher.class;
        //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        System.out.println("fields------------------");
        for(Field field:fields){
            System.out.println(field);
        }
        System.out.println("declaredFields------------------");
        //当前运行时类中声明的所有属性。(不包含父类中声明的属性)
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field field:declaredFields){
            System.out.println(field);
        }
    }
  • field.getModifiers():权限修饰符
  • field.getType():数据类型
  • field.getName():变量名
    @Test
    public void  test2(){
        Class<Teacher> clazz = Teacher.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field field:declaredFields){
            //权限修饰符
            int modifiers = field.getModifiers();
            System.out.print(Modifier.toString(modifiers)+" ");

            //2.数据类型
            Class<?> fieldType = field.getType();
            System.out.print(fieldType+" ");

            //3.变量名
            String fieldName = field.getName();
            System.out.println(fieldName);
        }
    }

获取方法结构

  • getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
  • getDeclaredMethods():获取当前运行时类中声明的所有方法
@Test                                                                
public void test1(){                                                 
    Class<Teacher> clazz = Teacher.class;                            
    //获取当前运行时类及其所有父类中声明为public权限的方法                                  
    Method[] methods = clazz.getMethods();                           
    for(Method method:methods){                                      
        System.out.println(method);                                  
    }                                                                
                                                                     
    //获取当前运行时类中声明的所有方法                                               
    Method[] declaredMethods = clazz.getDeclaredMethods();           
    for (Method method:declaredMethods){                             
        System.out.println(method);                                  
    }                                                                
}                                                                    
  • method.getAnnotations():获取方法声明的注解
  • method.getModifiers():获取方法的权限修饰符
  • method.getReturnType():返回值类型
  • method.getName():方法名
   @Test                                                                                  
   public void test2(){                                                                   
       Class<Teacher> clazz = Teacher.class;                                              
       Method[] declaredMethods = clazz.getDeclaredMethods();                             
       for (Method method:declaredMethods){                                               
           //1.获取方法声明的注解                                                                  
           Annotation[] annotations = method.getAnnotations();                            
           for (Annotation annotation:annotations){                                       
               System.out.println(annotation);                                            
           }                                                                              
                                                                                          
           //2.权限修饰符                                                                      
           int modifiers = method.getModifiers();                                         
           System.out.println(Modifier.toString(modifiers));                              
                                                                                          
           //3.返回值类型                                                                      
           System.out.println(method.getReturnType());                                    
                                                                                          
           //4.方法名                                                                        
           System.out.println(method.getName());                                          
                                                                                          
           //5.形参列表                                                                       
           Class<?>[] parameterTypes = method.getParameterTypes();                        
           if(!(parameterTypes == null && parameterTypes.length == 0)){                   
               for(int i = 0;i < parameterTypes.length;i++){                              
                    if(i == parameterTypes.length - 1){                                   
                         System.out.print(parameterTypes[i].getName() + " args_" + i);    
                          break;                                                          
                     }                                                                    
                   System.out.println(parameterTypes[i].getName()+" args_" + i + ",");    
               }                                                                          
           }                                                                              
       }                                                                                  
   }                                                                                      

获取构造器结构

  • getConstructors():获取当前运行时类中声明为public的构造器
  • getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
    @Test
    public void test1(){
        Class<Teacher>  clazz = Teacher.class;
        //getConstructors():获取当前运行时类中声明为public的构造器
        Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor constructor:constructors){
            System.out.println(constructor);
        }

        //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
        Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor constructor:declaredConstructors){
            System.out.println(constructor);
        }
    }

调用运行时类指定属性

  • field.setAccessible(true):设置当前属性是可访问的
  • field.set():指定属性值
   @Test
    public void test1(){
        Class<Teacher> clazz = Teacher.class;
        //创建运行时类的对象
        try {
            Teacher teacher = clazz.newInstance();
            Field name = clazz.getDeclaredField("name");
            //2.保证当前属性是可访问的
            name.setAccessible(true);
            name.set(teacher,"refine");
            System.out.println(name.get(teacher));
        } catch (InstantiationException |IllegalAccessException | NoSuchFieldException e) {
            throw new RuntimeException(e);
        }
    }

调用运行时类指定方法

  • getDeclaredMethod():获取指定的某个方法.参数1 :指明获取的方法的名称 参数2:指明获取的方法的形参列表
  • method.setAccessible(true):设置方法为可访问的
  • method.invoke():参数1:方法的调用者;参数2:给方法形参赋值的实参。返回值即为对应类中调用的方法的返回值。
    @Test
    public void test2(){
        Class<Teacher> clazz = Teacher.class;
        //创建运行时类的对象
        try {
            Teacher teacher = clazz.newInstance();
//          getDeclaredMethod():获取指定的某个方法.参数1 :指明获取的方法的名称  参数2:指明获取的方法的形参列表
            Method show = clazz.getDeclaredMethod("show",String.class);
            show.setAccessible(true);
            // 调用方法的invoke():参数1:方法的调用者  参数2:给方法形参赋值的实参
            //        invoke()的返回值即为对应类中调用的方法的返回值。
            Object china = show.invoke(teacher, "china");
            System.out.println(china);
        } catch (InstantiationException | IllegalAccessException  | NoSuchMethodException |
                 InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }

调用运行时类指定构造器

  • clazz.getDeclaredConstructor():参数:指明构造器的参数列表
    @Test
    public void test3(){
        Class<Teacher> clazz = Teacher.class;
        try {
            Teacher teacher = clazz.newInstance();
            Constructor<Teacher> constructor = clazz.getDeclaredConstructor(String.class);
            constructor.setAccessible(true);
            Teacher lucy = constructor.newInstance("LUCY");
            System.out.println(lucy);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }
  • 3
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梅尝酥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值