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这个关键字

目录
相关文章
|
12天前
|
Java 数据库连接 开发者
Java的Shutdown Hook机制:优雅地关闭应用程序
Java的Shutdown Hook机制:优雅地关闭应用程序
19 1
|
14天前
|
Java 程序员 开发者
深入理解Java并发编程:线程同步与锁机制
【4月更文挑战第30天】 在多线程的世界中,确保数据的一致性和线程间的有效通信是至关重要的。本文将深入探讨Java并发编程中的核心概念——线程同步与锁机制。我们将从基本的synchronized关键字开始,逐步过渡到更复杂的ReentrantLock类,并探讨它们如何帮助我们在多线程环境中保持数据完整性和避免常见的并发问题。文章还将通过示例代码,展示这些同步工具在实际开发中的应用,帮助读者构建对Java并发编程深层次的理解。
|
8天前
|
Java C++
Java反射的简单使用
Java反射的简单使用
20 3
|
1天前
|
消息中间件 安全 前端开发
字节面试:说说Java中的锁机制?
Java 中的锁(Locking)机制主要是为了解决多线程环境下,对共享资源并发访问时的同步和互斥控制,以确保共享资源的安全访问。 锁的作用主要体现在以下几个方面: 1. **互斥访问**:确保在任何时刻,只有一个线程能够访问特定的资源或执行特定的代码段。这防止了多个线程同时修改同一资源导致的数据不一致问题。 2. **内存可见性**:通过锁的获取和释放,可以确保在锁保护的代码块中对共享变量的修改对其他线程可见。这是因为 Java 内存模型(JMM)规定,对锁的释放会把修改过的共享变量从线程的工作内存刷新到主内存中,而获取锁时会从主内存中读取最新的共享变量值。 3. **保证原子性**:锁
12 1
|
2天前
|
安全 Java 数据安全/隐私保护
Java一分钟之-Java反射机制:动态操作类与对象
【5月更文挑战第12天】本文介绍了Java反射机制的基本用法,包括获取Class对象、创建对象、访问字段和调用方法。同时,讨论了常见的问题和易错点,如忽略访问权限检查、未捕获异常以及性能损耗,并提供了相应的避免策略。理解反射的工作原理和合理使用有助于提升代码灵活性,但需注意其带来的安全风险和性能影响。
17 4
|
5天前
|
Java 数据安全/隐私保护
java中异常处理机制
java中异常处理机制
11 1
|
5天前
|
算法 安全 Java
深入探索Java中的并发编程:CAS机制的原理与应用
总之,CAS机制是一种用于并发编程的原子操作,它通过比较内存中的值和预期值来实现多线程下的数据同步和互斥,从而提供了高效的并发控制。它在Java中被广泛应用于实现线程安全的数据结构和算法。
21 0
|
6天前
|
Java API 开发者
解密Java反射机制与动态代理
解密Java反射机制与动态代理
10 0
|
8天前
|
Java 数据库连接 开发者
Java中的异常处理机制详解
Java异常处理是确保程序健壮的关键,涉及Throwable的Error和Exception子类。Error由JVM抛出,不建议捕获;Exception分为检查异常(需要捕获)和未检查异常。处理异常的关键字有try、catch、finally、throw和throws。最佳实践包括捕获具体异常、不吞没异常、释放资源和避免滥用异常。示例展示了如何在main方法中处理IOException,并在finally块中进行资源清理。
12 1
|
8天前
|
SQL 存储 Java
【Java反射详解】
【Java反射详解】
11 1