• Java基础深化和提高 ---- 反射技术

    目录

    反射机制介绍

     什么是反射

     反射的作用

    创建对象过程 

    Java创建对象的三个阶段

     创建对象时内存结构

    反射的具体实现 

     创建Users类

    通过getClass()方法获取Class对象

    通过.class 静态属性获取Class对象

    通过forName()获取Class对象

    获取类的构造方法

    通过构造方法创建对象

    获取类的成员变量

    方法介绍

     方法使用

    获取成员变量

    操作成员变量

    获取类的方法

    方法介绍

     方法使用

    获取方法

    调用方法

    获取类的其他信息

    反射应用案例

    反射机制的效率

    反射机制的效率测试 

    setAccessible方法

    本章总结

    反射机制介绍

     什么是反射

    Java 反射机制是Java语言一个很重要的特性，它使得Java具有了“动 态性”。在Java程序运行时，对于任意的一个类，我们能不能知道这 个类有哪些属性和方法呢？对于任意的一个对象，我们又能不能调 用它任意的方法？答案是肯定的！这种动态获取类的信息以及动态 调用对象方法的功能就来自于Java 语言的反射（Reflection）机 制。

     反射的作用

    简单来说两个作用，RTTI（运行时类型识别）和DC（动态创建）。 我们知道反射机制允许程序在运行时取得任何一个已知名称的class 的内部信息，包括其modifiers(修饰符)，fields(属性)，methods(方 法)等，并可于运行时改变fields内容或调用methods。那么我们便 可以更灵活的编写代码，代码可以在运行时装配，无需在组件之间 进行源代码链接，降低代码的耦合度；还有动态代理的实现等等； 但是需要注意的是反射使用不当会造成很高的资源消耗！

    创建对象过程 

    Java创建对象的三个阶段

     创建对象时内存结构

    Users user = new Users();

     实际上，我们在加载任何一个类时都会在方法区中建立“这个类对应 的Class对象”，由于“Class对象”包含了这个类的整个结构信息，所 以我们可以通过这个“Class对象”来操作这个类。 我们要使用一个类，首先要加载类；加载完类之后，在堆内存中， 就产生了一个 Class 类型的对象（一个类只有一个 Class 对象）， 这个对象就包含了完整的类的结构信息。我们可以通过这个对象知 道类的结构。这个对象就像一面镜子，透过这个镜子可以看到类的 结构，所以，我们形象的称之为：反射。 因此，“Class对象”是反射 机制的核心。

    反射的具体实现 

    获取Class对象的三种方式

     1、通过getClass()方法;

     2、通过.class 静态属性;

     3、通过Class类中的静态方法forName();

     创建Users类

    1. public class Users {
    2.     private String username;
    3.     private int userage;
    4.     public String getUsername() {
    5.         return username;
    6.       }
    7.    public void setUsername(String username)
    8.      {
    9.         this.username = username;
    10.      }
    11.    public int getUserage() {
    12.         return userage;
    13.       }
    14.     public void setUserage(int userage) {
    15.         this.userage = userage;
    16.    }
    17. }

    通过getClass()方法获取Class对象

    1. * 通过getClass()方法获取该类的Class对象
    2. */
    3. public class GetClass1 {
    4.     public static void main(String[] args) {
    5.         Users users = new Users();
    6.         Users users1 = new Users();
    7.         Class clazz = users.getClass();
    8.         System.out.println(clazz);
    9.         System.out.println(clazz.getName());
    10.         System.out.println(users.getClass() == users1.getClass());
    11.    }
    12. }

    通过.class 静态属性获取Class对象

    1. /**
    2. * .class静态属性获取Class对象
    3. */
    4. public class GetClass2 {
    5.     public static void main(String[] args) {
    6.         Class clazz = Users.class;
    7.         Class clazz2 = Users.class;
    8.         System.out.println(clazz);
    9.         System.out.println(clazz.getName());
    10.         System.out.println(clazz == clazz2);
    11.    }
    12. }

    通过forName()获取Class对象

    1. /**
    2. * 通过Class.forName("class Name")获取Class对象
    3. */
    4. public class GetClass3 {
    5.     public static void main(String[] args)throws Exception {
    6.         Class clazz = Class.forName("com.bjsxt.Users");
    7.         Class clazz2 = Class.forName("com.bjsxt.Users");
    8.         System.out.println(clazz);
    9.         System.out.println(clazz.getName());
    10.         System.out.println(clazz == clazz2);
    11.    }
    12. }

    获取类的构造方法

    方法介绍

     方法使用

    修改Users类

    1. public class Users {
    2.     private String username;
    3.     private int userage;
    4.     public Users(){}
    5.     public Users(String username,int userage){
    6.         this.username= username;
    7.         this.userage=userage;
    8.    }
    9.    
    10.  public  Users(String username){
    11.         this.username= username;
    12.    }
    13.    
    14.  private Users(int userage){
    15.         this.userage = userage;
    16.    }
    17.    
    18.  public String getUsername() {
    19.         return username;
    20.    }
    21.     
    22.  public void setUsername(String username)
    23.    {
    24.         this.username = username;
    25.    }
    26.     
    27.  public int getUserage() {
    28.         return userage;
    29.    }
    30.  public void setUserage(int userage) {
    31.         this.userage = userage;
    32.    }
    33. }

    获取构造方法

    1. public class GetConstructor {
    2.     public static void main(String[] args)throws Exception {
    3.         Class clazz = Users.class;
    4.         Constructor[]  arr = clazz.getDeclaredConstructors();
    5.         for(Constructor c:arr){
    6.             System.out.println(c);
    7.        }
    8.         System.out.println("---------------------");
    9.         Constructor[]  arr1 = clazz.getConstructors();
    10.         for(Constructor c:arr1){
    11.             System.out.println(c);
    12.        }
    13.         System.out.println("------------------------");
    14.         Constructor c =   clazz.getDeclaredConstructor(int.class);
    15.         System.out.println(c);
    16.         System.out.println("------------------------");
    17.         Constructor c1 =   clazz.getConstructor(null);
    18.         System.out.println(c1);
    19.    }
    20. }

    通过构造方法创建对象

    1. public class GetConstructor2 {
    2.     public static void main(String[] args)throws Exception {
    3.         Class clazz = Users.class;
    4.         Constructor constructor = clazz.getConstructor(String.class,int.class);
    5.         Object o = constructor.newInstance("OldLu",18);
    6.         Users users = (Users)o;
    7.       System.out.println(users.getUsername()+"\t"+ users.getUserage());
    8.    }
    9. }

    获取类的成员变量

    方法介绍

     方法使用

    修改Users类

    1. public class Users {
    2.     private String username;
    3.     public int userage;
    4.     public Users(){
    5.    }
    6.     
    7.     public Users(String username,int userage){
    8.         this.username= username;
    9.         this.userage=userage;
    10.       }
    11.     
    12.     public  Users(String username){
    13.         this.username= username;
    14.       }
    15.     
    16.     private Users(int userage){
    17.         this.userage = userage;
    18.       }
    19.  
    20.     public String getUsername() {
    21.         return username;
    22.       }
    23.     public void setUsername(String username)
    24.       {
    25.         this.username = username;
    26.       }
    27.     public int getUserage() {
    28.         return userage;
    29.       }
    30.     public void setUserage(int userage) {
    31.         this.userage = userage;
    32.    }
    33. }

    获取成员变量

    1. public class GetField {
    2.     public static void main(String[] args)throws Exception {
    3.         Class clazz = Users.class;
    4.         Field[] fields = clazz.getFields();
    5.         for(Field f:fields){
    6.             System.out.println(f);
    7.             System.out.println(f.getName());
    8.         }
    9.         System.out.println("------------------------");
    10.         Field[] fields2 =clazz.getDeclaredFields();
    11.         for(Field f:fields2){
    12.             System.out.println(f);
    13.             System.out.println(f.getName());
    14.        }
    15.         System.out.println("------------------------");
    16.         Field field = clazz.getField("userage");
    17.         System.out.println(field);
    18.         System.out.println("---------------------");
    19.         Field field1 = clazz.getDeclaredField("username");
    20.         System.out.println(field1);
    21.    }
    22. }

    操作成员变量

    1. public class GetField2 {
    2.     public static void main(String[] args)throws Exception {
    3.         Class clazz = Users.class;
    4.         Field field = clazz.getField("userage");
    5.         //对象实例化
    6.         Object obj = clazz.newInstance();
    7.         //为成员变量赋予新的值
    8.         field.set(obj,18);
    9.         //获取成员变量的值
    10.         Object o = field.get(obj);
    11.         System.out.println(o);
    12.    }
    13. }

    获取类的方法

    方法介绍

     方法使用

    修改Users类

    1. public class Users {
    2.     private String username;
    3.     public int userage;
    4.     public Users(){ }
    5.     public Users(String username,int userage){
    6.         this.username= username;
    7.         this.userage=userage;
    8.       }
    9.     public  Users(String username){
    10.         this.username= username;
    11.       }
    12.     private Users(int userage){
    13.         this.userage = userage;
    14.       }
    15.     public String getUsername() {
    16.         return username;
    17.       }
    18.     public void setUsername(String username)
    19.       {
    20.         this.username = username;
    21.       }
    22.     public int getUserage() {
    23.         return userage;
    24.       }
    25.     public void setUserage(int userage) {
    26.         this.userage = userage;
    27.       }
    28.     private void suibian(){
    29.         System.out.println("Hello Oldlu");
    30.    }
    31. }

    获取方法

    1. public class GetMethod {
    2.     public static void main(String[] args)throws Exception{
    3.         Class clazz = Users.class;
    4.         Method[] methods = clazz.getMethods();
    5.         for(Method m: methods){
    6.             System.out.println(m);
    7.             System.out.println(m.getName());
    8.        }
    9.         System.out.println("---------------------------");
    10.         Method[] methods2 = clazz.getDeclaredMethods();
    11.         for(Method m: methods2){
    12.             System.out.println(m);
    13.             System.out.println(m.getName());
    14.        }
    15.         System.out.println("--------------------------");
    16.         Method method = clazz.getMethod("setUserage", int.class);
    17.         System.out.println(method.getName());
    18.         System.out.println("--------------------------");
    19.         Method method1 = clazz.getDeclaredMethod("suibian");
    20.         System.out.println(method1.getName());
    21.    }
    22. }

    调用方法

    1. public class GetMethod2 {
    2.     public static void main(String[] args)throws  Exception {
    3.         Class clazz = Users.class;
    4.         Method method = clazz.getMethod("setUsername",String.class);
    5.          //实例化对象
    6.         Object obj = clazz.getConstructor(null).newInstance();
    7.         //通过setUserName赋值
    8.         method.invoke(obj,"oldlu");
    9.         //通过getUserName获取值
    10.         Method method1 = clazz.getMethod("getUsername");
    11.         Object value = method1.invoke(obj);
    12.         System.out.println(value);
    13.    }
    14. }

    获取类的其他信息

    1. public class GetClassInfo {
    2.     public static void main(String[] args) {
    3.         Class clazz = Users.class;
    4.         //获取类名
    5.         String className = clazz.getName();
    6.         System.out.println(className);
    7.         //获取包名
    8.         Package p = clazz.getPackage();
    9.         System.out.println(p.getName());
    10.         //获取超类
    11.         Class superClass = clazz.getSuperclass();
    12.         System.out.println(superClass.getName());
    13.         //获取该类实现的所有接口
    14.         Class[] interfaces = clazz.getInterfaces();
    15.         for(Class inter:interfaces){
    16.            System.out.println(inter.getName());
    17.        }
    18.    }
    19. }

    反射应用案例

    需求：根据给定的方法名顺序来决定方法的执行顺序。

    1. class Reflect {
    2.     public void method1(){
    3.       System.out.println("Method1.......");
    4.    }
    5.     public void method2(){
    6.        System.out.println("Method2.......");
    7.    }
    8.     public void method3(){
    9.        System.out.println("Method3.......");
    10.    }
    11. }
    12. public class ReflectDemo {
    13.     public static void main(String[] args)throws Exception {
    14.         Reflect rd = new Reflect();
    15.         if(args != null && args.length > 0){
    16.             //获取ReflectDemo的Class对象
    17.             Class clazz = rd.getClass();
    18.             //通过反射获取ReflectDemo下的所有方法
    19.             Method[] methods = clazz.getMethods();
    20.             for(String str :args){
    21.                 for(int i=0;i<methods.length;i++){ if(str.equalsIgnoreCase(methods[i].getName())){
    22.                       methods[i].invoke(rd);
    23.                         break;
    24.                    }
    25.                }
    26.            }
    27.        }else{
    28.             rd.method1();
    29.             rd.method2();
    30.             rd.method3();
    31.        }
    32.    }
    33. }

    反射机制的效率

    由于Java反射是要解析字节码，将内存中的对象进行解析，包括了 一些动态类型，而JVM无法对这些代码进行优化。因此，反射操作 的效率要比那些非反射操作低得多！ 接下来我们做个简单的测试来直接感受一下反射的效率。

    反射机制的效率测试 

    1. public class Test{
    2.     public static void main(String[] args) {
    3.         try {
    4.             //反射耗时
    5.             Class clazz = Class.forName("com.bjsxt.Users");
    6.             Users users = (Users) clazz.getConstructor(null).newInstance();
    7.             long reflectStart = System.currentTimeMillis();
    8.             Method method = clazz.getMethod("setUsername", String.class);
    9.             for(int i=0;i<100000000;i++){
    10.                method.invoke(users,"oldlu");
    11.            }
    12.             long reflectEnd = System.currentTimeMillis();
    13.             //非反射方式的耗时
    14.             long start = System.currentTimeMillis();
    15.             Users u = new Users();
    16.             for(int i=0;i<100000000;i++){
    17.                 u.setUsername("oldlu");
    18.            }
    19.             long end = System.currentTimeMillis();
    20.             System.out.println("反射执行时 间："+(reflectEnd - reflectStart)); System.out.println("普通方式执行时间："+(end - start));
    21.        } catch (Exception e) {
    22.             e.printStackTrace();
    23.        }
    24.    }
    25. }

    setAccessible方法

    setAccessible()方法： setAccessible是启用和禁用访问安全检查的开关。值为 true 则指示 反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指 示反射的对象应该实施 Java 语言访问检查;默认值为false。 由于JDK的安全检查耗时较多.所以通过setAccessible(true)的方式关 闭安全检查就可以达到提升反射速度的目的。

    1. public class Test2 {
    2.     public static void main(String[] args)throws Exception {
    3.         Users users = new Users();
    4.         Class clazz = users.getClass();
    5.         Field field = clazz.getDeclaredField("username");
    6.         //忽略安全检查
    7.         field.setAccessible(true);
    8.         field.set(users,"oldlu");
    9.         Object object = field.get(users); System.out.println(object);
    10.         System.out.println("-----------------------------");
    11.         Method method = clazz.getDeclaredMethod("suibian");
    12.         method.setAccessible(true);
    13.         method.invoke(users);
    14.    }
    15. }

    本章总结

    Java 反射机制是Java语言一个很重要的特性，它使得Java具有了 “动态性”。

    反射机制的优点：

        1、更灵活。

        2、更开放。

    反射机制的缺点：

        1、降低程序执行的效率。

        2、增加代码维护的困难。

    获取Class类的对象的三种方式：

       1、运用getClass()。

       2、运用.class 语法。

       3、运用Class.forName()（最常被使用）。

    反射机制的常见操作

       1、动态加载类、动态获取类的信息（属性、方法、构造器）。

       2、动态构造对象。

       3、动态调用类和对象的任意方法。

       4、动态调用和处理属性。

       5、 获取泛型信息。

       6、处理注解。

  • 相关阅读:
    人工智能基础部分21-神经网络中优化器算法的详细介绍，配套详细公式
    企业微信群发助手：加速信息传递，强化营销效果的新引擎
    微信小程序：时光映迹
    专科生的逆袭之路，比你想象中还要励志
    1.1 print输出语句（Python）
    DockerFile微服务实战
    Aztec.nr：Aztec的隐私智能合约框架——用Noir扩展智能合约功能
    「学习笔记」树链剖分
    『NLP学习笔记』TextCNN文本分类原理及Pytorch实现
    No126.精选前端面试题，享受每天的挑战和学习
  • 原文地址：https://blog.csdn.net/m0_58719994/article/details/127975923