Java基础篇:反射机制详解

简介: Java基础篇:反射机制详解

反射机制、反射含义

  • JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象, 都能够调用它的任意方法和属性;
  • 这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制
  • 帮助理解:就是我们可以通过代码获取到类中的所有属性和所有方法
  • 简而言之:自己找到自己,俗称“照镜子”

1.利用反射获取类对象的三种方法

  • 方法一:对象.getClass()方法
  • 方法二:类.clss属性
  • 方法三:Class.forName()

代码块

public class Test {
  public static void main(String[] args) throws Exception {
    //Student类的实例化
    Student student01= new Student(); 
    //方法一:通过getclass()
    Class<? extends Student> s1 = student01.getClass();
    System.out.println(s1);
    //方法二:通过class属性
    Class<Student> s2 = Student.class;
    System.out.println(s2);
    //方法三:通过Class.forname()
    System.out.println(Class.forName("com.Li.reflex01.Student"));
  }
}

2.利用反射获取类对象的类名、方法、属性

stu.getClass();


stu.getClass().getFields().getName() & field.getType() //属性名 和 属性类型


stu.getClass().getMethods().getName() & method.getReturnType() //类方法 和 方法返回值


/**
 * @Description: 测试类:测试获取类对象中的类名、方法和属性
 * @auther:Li Ya Hui
 * @Time:2021年4月19日下午1:33:00
   */
   public class Test {
   public static void main(String[] args) {
    //1.student类的实例化
    Student stu = new Student();
   //2.获取student的类对象  class
   Class<? extends Student> student = stu.getClass();
   System.out.println("类的class:\t"+student);
   System.out.println("类的全称:"+stu.getClass().getSimpleName());
   System.out.println("类的简称:"+stu.getClass().getName());
   //3使用增强for遍历学生类的属性  属性名,属性类型
   Field[] stufiled = stu.getClass().getFields();
   for (Field field : stufiled) {
    System.out.println("属性名:"+field.getName()+"\t\t属性的数据类型:"+field.getType());
   }
   //4.获取类中的方法
   Method[] stumethods = stu.getClass().getMethods();
   for (Method method : stumethods) {
    System.out.println("类的方法"+method.getName()+"\t类的方法的返回值类型"+method.getReturnType());
   }
 }
}

3.利用反射获取类对象中的构造器、构造器参数类型、实例化构造器

package com.Li.reflex03;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Test {
  public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    //获取类对象
    Class<?> stu = Class.forName("com.Li.reflex03.Student");
    //获取所有的公有构造方法(前提 类是用public修饰的)
    Constructor<?>[] stuConstru = stu.getConstructors();
    for (Constructor<?> constructor : stuConstru) {
      System.out.println("构造器:\t"+constructor);
      //构造器执行  (参数 类型 个数 不对会导致出错)
      //System.out.println("构造器执行:\t:"+constructor.newInstance(""));//等价于Student student = new Student(); 相当于类的初始化
      //获取构造器中的参数类型
      Class<?>[] parameterTypes = constructor.getParameterTypes();
      //遍历各个构造器参数类型
      for (Class<?> parameter : parameterTypes) {
        System.out.println("构造器中的参数类型:\t"+parameter.getName());
      }
      System.out.println();
    }
  }
}

实例化重点

类的加载方式不同

在执行Class.forName(“a.class.Name”)时,JVM会在classapth中去找对应的类并加载,这时JVM会执行该类的静态代码段。在使用newInstance()方法的时候,必须保证这个类已经加载并且已经连接了,而这可以通过Class的静态方法forName()来完成的。


使用关键字new创建一个类的时候,这个类可以没有被加载,一般也不需要该类在classpath中设定,但可能需要通过classlaoder来加载。

所调用的构造方法不尽相同

new关键字能调用任何构造方法。

newInstance()只能调用无参构造方法。

执行效率不同

new关键字是强类型的,效率相对较高。

newInstance()是弱类型的,效率相对较低。

4.利用反射获取类对象中的方法的包装类

/**
 * @Description:测试类,测试利用反射获取类的方法的包装类Method
 * @auther:Li Ya Hui
 * @Time:2021年4月19日下午8:57:13
 */
public class Test {
  public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
    //1.获取类对象
    Class<Student> ownerClass = Student.class; 
    //2.Student类的实例化
    Student student = ownerClass.newInstance();
    //3.通过类对象获取method类          方法名   方法返回值类型    需是类
     Method method = ownerClass.getMethod("sayHi", String.class);
     //多个参数时
     //Method method = ownerClass.getMethod("sayHi", String.class, String.class);
     //4.invoke() 是method类中的方法,起作用是回调类中的方法         
     //invoke 参数讲解: 1.回调那个实例化对象中的方法   2.传入的参数的值
     String result = (String) method.invoke(student, "LiYaHui");
     //多个参数时
//     String result = (String) method.invoke(student, "LiYaHui","李亚辉");
     System.out.println(result); 
  }
}

5.通过反射获取运行配置文件内容(Properties

properties位于java.util.properties,是Java语言的配置文件所使用的类

/**
 * @Description: 利用properties获取配置文件中的内容
 * @auther:Li Ya Hui
 * @Time:2021年4月20日上午9:14:52
 */
public class Test {
  public static void main(String[] args) throws IOException {
    //实例properties类
    Properties properties  = new Properties();
    //创建读取对象
    FileReader fileReader = new FileReader("dbconfig.txt");
    //加载读取对象
    properties.load(fileReader);
    //获取username属性
    String username = properties.getProperty("username");
    //打印username的值
    System.out.println(username);//打印 root
  }
}
自己写的配置文件
//dbconfig.txt
username=root
password=root
drivername=com.mysql.jdbc.driver
url=127.0.01:3306

6.利用反射和properties实现获取配置文件中的内容(类路径、方法名,然后反射实现 实例化、回调方法)

package com.Li.reflex05;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.ObjectInputStream.GetField;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;
/**
 * @Description: 利用反射和properties实现获取配置文件中的内容
 * @auther:Li Ya Hui
 * @Time:2021年4月20日上午9:39:51
 */
public class Test {
  public static void main(String[] args) throws Exception {
    //1.propertie类的初始化
    Properties properties = new Properties();
    //2.加载配置文件哎
    FileReader fileReader = new FileReader("playerList.txt");
    //3.properties加载配置文件
    properties.load(fileReader);
    //4.利用properties获取配置文件中的内容
    //当前的配置文件中的className的属性值,  得到应用类的路径
    String className = properties.getProperty("className"); 
    System.out.println("获取到的类的路径名:\t"+className);
    //当前的配置文件中的methodName的属性值,  得到类的方法名
    String methodName = properties.getProperty("methodName");
    System.out.println("获取到的类中方法的名字:\t"+methodName);
    //得到类的class
    Class<?> heroclass = Class.forName(className);
    //得到构造器
    Constructor constructor = heroclass.getConstructor();
    //初始化构造器,其作用相当于是new ,目前是实例化类
    Object hero = constructor.newInstance();
    //调用方法    getMethod使用类对象来调用的,所以不能用hero对象
    Method method = heroclass.getMethod(methodName, String.class);//通过类对象获取到方法的包装类Method,且同时指出本次执行的方法是run,且该方法的传入参数为String
    //回调hero类中的run方法
    method.invoke(hero,"ss枪手");
  }
}
//hero类
/**
 * @Description: 英雄类
 * @auther:Li Ya Hui
 * @Time:2021年4月20日上午9:36:45
 */
public class Hero {
  public void run(String attribute)
  {
    if (attribute.endsWith("肉盾")) 
    {
      System.out.println("肉盾!可以慢跑");
    }else if(attribute.endsWith("枪手")){
      System.out.println("枪手可以边打边跑");
    }else {
      System.out.println("可以正常跑!");
    }
  }
}
//配置文件
//playerList.txt
className=com.Li.reflex05.Hero
methodName=run

7.在不更改源代码的前提下通过更改配置文件实现程序功能的扩展

package com.Li.reflex07;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.ObjectInputStream.GetField;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;
/**
 * @Description: 在不更改源代码的前提下通过更改配置文件实现程序功能的扩展
 * @auther:Li Ya Hui
 * @Time:2021年4月20日上午9:39:51
 */
public class Test {
  public static void main(String[] args) throws Exception {
    //1.propertie类的初始化
    Properties properties = new Properties();
    //2.加载配置文件哎
    FileReader fileReader = new FileReader("playerList2.txt");
    //3.properties加载配置文件
    properties.load(fileReader);
    //4.利用properties获取配置文件中的内容
    //当前的配置文件中的className的属性值,  得到应用类的路径
    String className = properties.getProperty("className"); 
    System.out.println("获取到的类的路径名:\t"+className);
    //当前的配置文件中的methodName的属性值,  得到类的方法名
    String methodName = properties.getProperty("methodName");
    System.out.println("获取到的类中方法的名字:\t"+methodName);
    //得到类的class
    Class<?> heroclass = Class.forName(className);
    //得到构造器
    Constructor constructor = heroclass.getConstructor();
    //初始化构造器,其作用相当于是new ,目前是实例化类
    Object hero = constructor.newInstance();
    //调用方法    getMethod使用类对象来调用的,所以不能用hero对象
    Method method = heroclass.getMethod(methodName, String.class);//通过类对象获取到方法的包装类Method,且同时指出本次执行的方法是run,且该方法的传入参数为String
    //以上代码没有更改,封装后可实现多次扩展实例代码
    //回调hero类中的run方法
    method.invoke(hero,"boss"); //只需在调用时换参数即可
  }
}
//妖怪类(Devil)
package com.Li.reflex07;
/**
 * @Description: 妖怪类
 * @auther:Li Ya Hui
 * @Time:2021年4月20日上午9:36:45
 */
public class Devil {
  public void run(String attribute)
  {
    if (attribute.endsWith("boss")) 
    {
      System.out.println("boss!可以慢跑");
    }else if(attribute.endsWith("littleboss")){
      System.out.println("littleboss可以稍微快点跑");
    }else {
      System.out.println("可以正常跑!");
    }
  }
}
//配置文件//playerList2.txt
className=com.Li.reflex07.Devil
methodName=run

8.使用反射的小结

1.可以在任何地方通过反射获取到类中的属性和方法和构造器还有实例化


2.因为可以获取到构造器,当然也可以实例化==(通过newInstance()方法即可实现)==


3.经常被应用在框架中,例如Struts,Soring框架


要点:newInstance这个方法勉强等同于news这个关键字

目录
相关文章
|
4月前
|
设计模式 人工智能 安全
AQS:Java 中悲观锁的底层实现机制
AQS(AbstractQueuedSynchronizer)是Java并发包中实现同步组件的基础工具,支持锁(如ReentrantLock、ReadWriteLock)和线程同步工具类(如CountDownLatch、Semaphore)等。Doug Lea设计AQS旨在抽象基础同步操作,简化同步组件构建。 使用AQS需实现`tryAcquire(int arg)`和`tryRelease(int arg)`方法以获取和释放资源,共享模式还需实现`tryAcquireShared(int arg)`和`tryReleaseShared(int arg)`。
237 32
AQS:Java 中悲观锁的底层实现机制
|
2月前
|
人工智能 缓存 安全
Java中的反射机制:深入探索与应用
Java反射机制是程序运行时动态获取类信息并操作类成员的特性,具备高度灵活性,但也伴随性能与安全风险。本文详解反射的基本用法、高级应用及最佳实践,助你掌握这一强大工具的正确使用方式。
134 0
|
4月前
|
人工智能 Java 关系型数据库
Java——SPI机制详解
SPI(Service Provider Interface)是JDK内置的服务提供发现机制,主要用于框架扩展和组件替换。通过在`META-INF/services/`目录下定义接口实现类文件,Java程序可利用`ServiceLoader`动态加载服务实现。SPI核心思想是解耦,允许不同厂商为同一接口提供多种实现,如`java.sql.Driver`的MySQL与PostgreSQL实现。然而,SPI存在缺陷:需遍历所有实现并实例化,可能造成资源浪费;获取实现类方式不够灵活;多线程使用时存在安全问题。尽管如此,SPI仍是Java生态系统中实现插件化和模块化设计的重要工具。
157 0
|
2月前
|
人工智能 前端开发 安全
Java开发不可不知的秘密:类加载器实现机制
类加载器是Java中负责动态加载类到JVM的组件,理解其工作原理对开发复杂应用至关重要。本文详解类加载过程、双亲委派模型及常见类加载器,并介绍自定义类加载器的实现与应用场景。
185 4
|
2月前
|
人工智能 安全 Java
掌握Java反射:在项目中高效应用反射机制
Java反射是一种强大功能,允许程序在运行时动态获取类信息、创建对象、调用方法和访问字段,提升程序灵活性。它在框架开发、动态代理、注解处理等场景中广泛应用,如Spring和Hibernate。但反射也存在性能开销、安全风险和代码复杂性,应谨慎使用。
|
3月前
|
人工智能 Java
Java中的反射机制:深入探索与应用
本文介绍了Java反射机制的基本概念、用途及其实现方式。反射机制允许程序在运行时动态获取类的属性和方法,并调用它们,适用于处理私有成员或权限受限的情况。文章详细讲解了`Class`类的功能,包括获取类的方法、属性、注解、构造器等信息,以及通过四种方式获取`Class`对象的示例代码。此外,还探讨了类加载器、继承关系判断、动态代理等高级内容,展示了如何在运行时创建接口实例并处理方法调用。文末提供了完整的代码示例以加深理解。
Java中的反射机制:深入探索与应用
|
4月前
|
Java 区块链 网络架构
酷阿鲸森林农场:Java 区块链系统中的 P2P 区块同步与节点自动加入机制
本文介绍了基于 Java 的去中心化区块链电商系统设计与实现,重点探讨了 P2P 网络在酷阿鲸森林农场项目中的应用。通过节点自动发现、区块广播同步及链校验功能,系统实现了无需中心服务器的点对点网络架构。文章详细解析了核心代码逻辑,包括 P2P 服务端监听、客户端广播新区块及节点列表自动获取等环节,并提出了消息签名验证、WebSocket 替代 Socket 等优化方向。该系统不仅适用于农业电商,还可扩展至教育、物流等领域,构建可信数据链条。
|
4月前
|
人工智能 JavaScript Java
Java反射机制及原理
本文介绍了Java反射机制的基本概念、使用方法及其原理。反射在实际项目中比代理更常用,掌握它可以提升编程能力并理解框架设计原理。文章详细讲解了获取Class对象的四种方式:对象.getClass()、类.class、Class.forName()和类加载器.loadClass(),并分析了Class.forName()与ClassLoader的区别。此外,还探讨了通过Class对象进行实例化、获取方法和字段等操作的具体实现。最后从JVM类加载机制角度解析了Class对象的本质及其与类和实例的关系,帮助读者深入理解Java反射的工作原理。
104 0
|
6月前
|
缓存 Dubbo Java
理解的Java中SPI机制
本文深入解析了JDK提供的Java SPI(Service Provider Interface)机制,这是一种基于接口编程、策略模式与配置文件组合实现的动态加载机制,核心在于解耦。文章通过具体示例介绍了SPI的使用方法,包括定义接口、创建配置文件及加载实现类的过程,并分析了其原理与优缺点。SPI适用于框架扩展或替换场景,如JDBC驱动加载、SLF4J日志实现等,但存在加载效率低和线程安全问题。
277 7
理解的Java中SPI机制
|
5月前
|
存储 Java 编译器
Java 中 .length 的使用方法:深入理解 Java 数据结构中的长度获取机制
本文深入解析了 Java 中 `.length` 的使用方法及其在不同数据结构中的应用。对于数组,通过 `.length` 属性获取元素数量;字符串则使用 `.length()` 方法计算字符数;集合类如 `ArrayList` 采用 `.size()` 方法统计元素个数。此外,基本数据类型和包装类不支持长度属性。掌握这些区别,有助于开发者避免常见错误,提升代码质量。
469 1