【Java SE】14. 反射

最新推荐文章于 2024-06-09 17:42:15 发布
最新推荐文章于 2024-06-09 17:42:15 发布
阅读量151 收藏
点赞数
分类专栏： JavaSE 文章标签： 反射
原文链接：https://blog.csdn.net/Qmilumilu/article/details/119518425
版权

14. 反射

14.1 Java反射机制概述

  1. Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

  2. 加载完类之后， 在堆内存的方法区中就产生了一个Class类型的对象（ 一个类只有一个Class对象） ， 这个对象就包含了完整的类的结构信息。 我们可以通过这个对象看到类的结构。 这个对象就像一面镜子， 透过这个镜子看到类的结构， 称之为：反射

    在这里插入图片描述

  3. Java反射机制提供的功能

    1. 在运行时判断任意一个对象所属的类
    2. 在运行时构造任意一个类的对象
    3. 在运行时判断任意一个类所具有的成员变量和方法
    4. 在运行时获取泛型信息
    5. 在运行时调用任意一个对象的成员变量和方法
    6. 在运行时处理注解
    7. 生成动态代理

  4. 反射相关的主要API

    1. java.lang.Class：代表一个类 （Class ≠ \neq ​=class，Class是用来描述类的类）
    2. java.lang.reflect.Method：代表类的方法
    3. java.lang.reflect.Field：代表类的成员变量
    4. java.lang.reflect.Constructor：代表类的构造器
    5. … …

14.2 理解Class类并获取Class实例

  1. 反射之前，对Person类的操作

    //使用Person构造器，实例化对象
Person p1 = new Person();

//通过对象调用其内部的属性、方法
p1.age = 10;
System.out.println(p1.toString());
p1.eat();

//⭐在Person类外部，不可以通过Person类的对象调用其内部私有结构
//p1.name;

  2. 反射之后，对Person类的操作

    //通过反射，创建Person类的对象
Class<Person> clazz = Person.class;
Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
Person p1 = constructor.newInstance("Tom", 21);
System.out.println(p1.toString());

//通过反射调用属性、方法
Field age = clazz.getDeclaredField("age");
age.set(p1,10);

Method eat = clazz.getDeclaredMethod("eat");
eat.invoke(p1);

    //⭐通过反射是可以调用私有结构的

//1.调用私有构造器
Constructor<Person> constructor1 = clazz.getDeclaredConstructor(String.class);
constructor1.setAccessible(true);
Person p2 = constructor1.newInstance("Jack");
System.out.println(p2);

//2.调用私有属性和方法
Field name = clazz.getDeclaredField("name");
name.setAccessible(true);
name.set(p2,"Mike");
System.out.println(p2);

//3.调用私有方法
Method talk = clazz.getDeclaredMethod("talk");
talk.setAccessible(true);
talk.invoke(p1);

  3. 关于java.lang.Class类的理解：

    1. 类的加载过程：

      程序经过javac.exe命令之后，会生成一个或多个字节码文件（.class结尾），接着我们使用java.exe命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中。加载到内存中的类，就称为运行时类，此运行时类，就作为Class的一个实例（类也是对象）

    2. Class的实例就对应着一个运行时类

    3. 加载到内存中的运行时类，会缓存一段时间。在此时间内，我们可以通过不同方式来获取此运行时类

  4. 获取Class实例的四种方式：

    //方式一：调用运行时类的属性 .class
Class<Person> clazz1 = Person.class;
System.out.println(clazz1);

//方式二：通过运行时类的对象，调用getClass()
Person p = new Person();
Class<? extends Person> clazz2 = p.getClass();
System.out.println(clazz2);

//⭐方式三：（使用较多）调用Class的静态方法：forName(String classPath)
Class<?> clazz3 = Class.forName("com.demo5.Person");
System.out.println(clazz3);

//方式四：（了解）使用类的加载器：ClassLoader
ClassLoader classLoader = test.class.getClassLoader();
Class<?> clazz4 = classLoader.loadClass("com.demo5.Person");
System.out.println(clazz4);

  5. 哪些类型可以有Class对象？

    1. class：外部类， 成员(成员内部类， 静态内部类)， 局部内部类， 匿名内部类

    2. interface： 接口

    3. [ ]：数组

    4. enum：枚举

    5. annotation：注解@interface

    6. primitive type：基本数据类型

    7. void

      Class c1 = Object.class;
Class c2 = Comparable.class;
Class c3 = String[].class;
Class c4 = int[][].class;
Class c5 = ElementType.class;
Class c6 = Override.class;
Class c7 = int.class;
Class c8 = void.class;
Class c9 = Class.class;

int[] a = new int[10];
int[] b = new int[100];
Class c10 = a.getClass();
Class c11 = b.getClass();
// 只要元素类型与维度一样，就是同一个Class
System.out.println(c10 == c11);

14.3 类的加载与ClassLoader的理解

  1. 当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化

    在这里插入图片描述

  2. 类加载器的作用：

    1. 类加载的作用： 将class文件字节码内容加载到内存中， 并将这些静态数据转换成方法区的运行时数据结构， 然后在堆中生成一个代表这个类的java.lang.Class对象， 作为方法区中类数据的访问入口

    2. 类缓存： 标准的JavaSE类加载器可以按要求查找类， 但一旦某个类被加载到类加载器中， 它将维持加载（缓存）一段时间。 不过JVM垃圾回收机制可以回收这些Class对象

      在这里插入图片描述

  3. 使用ClassLoader加载配置文件

    //之前的方式一：
public static void main(String[] args) {
    FileInputStream fileInputStream = null;
    try {
        Properties properties = new Properties();
        
        fileInputStream = new FileInputStream("jdbc.properties");
        properties.load(fileInputStream);

        String name = properties.getProperty("name");
        String password = properties.getProperty("password");
        System.out.println(name+"-"+password);
    		//TOM-123
        
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(fileInputStream != null){
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    //方式二：
InputStream ras = null;
try {
    Properties properties = new Properties();

    ClassLoader classLoader = test.class.getClassLoader();
    
    ras = classLoader.getResourceAsStream("jdbc.properties");
    //配置文件需要在当前module的src下
    
    properties.load(ras);

    String name = properties.getProperty("name");
    String password = properties.getProperty("password");
    System.out.println(name+"-"+password);
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if(ras != null)
            ras.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

14.4 通过反射-创建运行时类的对象

  1. 有了Class对象后，可以调用Class对象的newInstance()方法，创建运行时类的对象

    Class<?> clazz = Class.forName("com.demo5.Person");

//newInstance():调用此方法，创建对应的运行时类的对象，内部调用了运行时类的空参构造器
//条件:
// 1.运行时类必须提供空参构造器(InstantiationException)
// 2.空参构造器的访问权限够(IllegalAccessException)

//在javabean中要求提供一个public的空参构造器
//1.便于通过反射，创建运行时类的对象
//2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
Person person = (Person) clazz.newInstance();
System.out.println(person);

  2. 体会反射的动态性：(编译完成后，并不能确定要造哪个类的对象)

    public class test {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {

        while (true) {
            int i = new Random().nextInt(3);
            String classPath = "";
            switch (i){
                case 0:
                    System.out.println(i);
                    classPath = "java.util.Date";
                    break;
                case 1:
                    System.out.println(i);
                    classPath = "java.lang.String";
                    break;
                case 2:
                    System.out.println(i);
                    classPath = "com.demo5.Person";
                    break;
            }

            Object instance = getInstance(classPath);
            System.out.println(instance);
            /*
            0
            Wed Jun 16 08:57:20 CST 2021
            2
            Person{name='null', age=0}
            2
            Person{name='null', age=0}
            */
        }
    }

    public static Object getInstance(String classPath) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class<?> clazz = Class.forName(classPath);
        Object o = clazz.newInstance();
        return o;
    }
}

14.5 通过反射-获取运行时类的完整结构

  1. 使用反射可以取得

    1. ⭐实现的全部接口
      Class<?>[] getInterfaces()：确定此对象所表示的类或接口实现的接口

    2. ⭐所继承的父类
      Class<? Super T> getSuperclass()：返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的Class

    3. ⭐全部的构造器
      Constructor<T>[] getConstructors()：返回此 Class 对象所表示的类的所有public构造方法Constructor<T>[] getDeclaredConstructors()：返回此 Class 对象表示的类声明的所有构造方法

      Constructor类中：

      1. 取得修饰符: public int getModifiers();
      2. 取得方法名称: public String getName();
      3. 取得参数的类型： public Class<?>[] getParameterTypes();

    4. 全部的方法

      Method[] getDeclaredMethods()：返回此Class对象所表示的类或接口的全部方法（不含父类）

      Method[] getMethods()：返回此Class对象（及其父类）所表示的类或接口的public的方法

      Method类中：

      1. Class<?> getReturnType()取得全部的返回值
      2. Class<?>[] getParameterTypes()取得全部的参数
      3. int getModifiers()取得修饰符（显示表示：Modifier.toString(getModifiers()) ）
      4. Class<?>[] getExceptionTypes()取得异常信息

    5. .全部的Field（属性）

      Field[] getFields()：返回此Class对象（及其父类）所表示的类或接口的public的Field
      Field[] getDeclaredFields()：返回此Class对象所表示的类或接口的全部Field（不含父类）
      Field方法中：

      1. int getModifiers() 以整数形式返回此Field的修饰符
      2. Class<?> getType() 得到Field的属性类型
      3. String getName() 返回Field的名称

    6. Annotation相关

      getAnnotation(Class<T> annotationClass)

      getDeclaredAnnotations()

    7. ⭐泛型相关

      1. 获取父类泛型类型： Type getGenericSuperclass()
      2. 泛型类型： ParameterizedType
      3. 获取实际的泛型类型参数数组： getActualTypeArguments()

    8. 类所在的包

      Package getPackage()

14.6 通过反射-调用运行时类的指定结构

  1. 调用指定属性：

    1. 在反射机制中，可以直接通过Field类操作类中的属性

    2. 通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作

      1. Object get(Object obj) 取得指定对象obj上此Field的属性内容

      2. void set(Object obj,Object value) 设置指定对象obj上此Field的属性内容

        Class<?> clazz = Class.forName("com.demo5.Person");
Person p1 = (Person) clazz.newInstance();

//getField()只能获取public的，故不常使用
Field age = clazz.getDeclaredField("age");
age.set(p1,100);
System.out.println(age.get(p1));

Field name = clazz.getDeclaredField("name");
//name.set(p1,"hh");//IllegalAccessException没有权限
name.setAccessible(true);
name.set(p1,"hh");

  2. 调用指定方法：

    通过反射，调用类中的方法，通过Method类完成

    在这里插入图片描述

    1. 通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型

    2. 之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息

      Class<?> clazz = Class.forName("com.demo5.Person");
Person p1 = (Person) clazz.newInstance();

//无参方法
Method eat = clazz.getDeclaredMethod("eat");
eat.invoke(p1);

//有参方法
Method talk = clazz.getDeclaredMethod("talk", String.class);
talk.invoke(p1,"参数2记得传入");

//私有方法
Method look = clazz.getDeclaredMethod("look");
//look.invoke(p1);  //IllegalArgumentException权限不够
look.setAccessible(true);
look.invoke(p1);

//静态方法：(要用Class对象invoke)
Method show = clazz.getDeclaredMethod("show");
show.invoke(Class.forName("com.demo5.Person"));
//或者：show.invoke(Person.class);

//如果调用的运行时类中的方法没有返回值，则invoke()返回null
//Object returnValue = show.invoke(Person.class);
//System.out.println(returnValue); //null

  3. 调用指定构造器：

    Class<?> clazz = Class.forName("com.demo5.Person");

Constructor<?> constructor1 = clazz.getDeclaredConstructor();

Constructor<?> constructor2 = clazz.getDeclaredConstructor(String.class);

constructor2.setAccessible(true);

Person tom = (Person) constructor2.newInstance("Tom");
System.out.println(tom);

14.7 反射的应用：动态代理

  1. 代理设计模式的原理：

    1. 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象
    2. 任何对原始对象的调用都要通过代理
    3. 代理对象决定是否以及何时将方法调用转到原始对象上

  2. 静态代理存在的缺点：

    1. 特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展
    2. 每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理
    3. 故最好可以通过一个代理类完成全部的代理功能

  3. 动态代理：

    1. 客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象

    2. 动态代理使用场合:

      1. 调试
      2. 远程方法调用

    3. 动态代理相比于静态代理的优点：

      抽象角色中 （接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法

  4. 示例：

    1. 静态代理：代理类和被代理类在编译期间，就确定下来了

      //工厂接口
interface Factory{
    void produce();
}

//代理工厂
class proxyFactory implements Factory{

    //拿被代理类对象进行初始化
    private Factory factory;

    public proxyFactory(Factory factory) {
        this.factory = factory;
    }

    @Override
    public void produce() {
        System.out.println("代理工厂做一些准备工作");
        
        factory.produce();//调用的是被代理类的produce()方法
       
        System.out.println("代理工厂做一些后续工作");
    }
}

//被代理工厂
class oneFactory implements Factory{

    @Override
    public void produce() {
        System.out.println("A工厂生产一批产品");
    }
}

//测试类
public class test {
    public static void main(String[] args)  {
        oneFactory oneFactory = new oneFactory();
        proxyFactory proxyFactory = new proxyFactory(oneFactory);
        proxyFactory.produce();
    }
}

    2. ⭐动态代理：

      1. 问题一：如何根据加载到内存中的被代理类，动态地创建一个代理类及其对象
      2. 问题二：当通过代理类的对象调用方法a时，如何动态地去调用被代理类中的同名方法a
      //🟢共同接口
interface Human{
    void getIfo();
    void eat(String food);
}

//🔵被代理类
class Man implements Human{

    @Override
    public void getIfo() {
        System.out.println("我是一个男人");
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}

//🟠创建代理对象的类
class proxyFctory{
    //调用此方法，返回一个代理类对象。解决问题一
    //声明成静态方法，方便用类名直接调用
    public static Object getproxyInstance(Object obj){//此处obj是被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        //构造代理对象，需要知道被代理对象的类加载器，实现的接口，和一个调用处理器InvocationHandler
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}

//🟣构造调用处理器handler的类
class MyInvocationHandler implements InvocationHandler{

    //需要使用被代理类的对象进行赋值
    private  Object object;
    public void bind(Object obj){
        this.object = obj;//object即为被代理类对象
    }
    //当通过代理类对象，调用方法a时，就会自动调用如下方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    //invoke：调用
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象调用的方法
        //object即为被代理类对象
        Object returnValue = method.invoke(object, args);
        return returnValue;
    }
}

//🟡测试类
public class test {
    public static void main(String[] args)  {
        Man man = new Man();
        //proxyInstance代理类的对象
        Human proxyInstance = (Human) proxyFctory.getproxyInstance(man);
        //当通过代理类对象调用方法时，会自动的调用被代理类中的同名方法
        //⭐这里getIfo、eat在被调用时，充当了invoke中的method
        proxyInstance.getIfo();
        proxyInstance.eat("包子");
    }
}

  5. 动态代理与AOP（Aspect Orient Programming)

    1. 前面介绍的Proxy和InvocationHandler，很难看出这种动态代理的优势，下面介绍一种更实用的动态代理机

      在这里插入图片描述

    2. 这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法

    3. 但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理

      在这里插入图片描述

coolcoo1cool
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
错误java.lang.reflect_java.lang.reflect.InvocationTargetException
weixin_35103924的博客
02-27 3282
java.lang.reflect.InvocationTargetException错误java.lang.reflect.InvocationTargetException'>java.lang.reflect.InvocationTargetException异常在JBOSS内执行程序，总是报这个异常。但是我用bat文件直接运行又没有问题。以下是bat文件的代码：echooffif"%...
Java基础篇——反射&枚举
m0_63615119的博客
08-21 1526
Java基础篇——反射&枚举
Java复习14-反射
cher_Van的博客
02-28 60
Java反射机制：是指在运行时取获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展。
JavaSE之第十四章反射
weixin_45603326的博客
08-09 183
JavaSE之第十四章反射
已解决java.lang.NoSuchMethodException异常的正确解决方法，亲测有效！！！
小明的Java问道之路
01-15 4万+
已解决java.lang.NoSuchMethodException异常的正确解决方法，亲测有效！！！
深入理解 Java 反射：Field （成员变量）
热门推荐
张拭心的博客 shixinzhang
01-18 5万+
读完本文你将了解到： Field 成员变量的介绍 获取变量的类型 获取成员变量的修饰符 获取和修改成员变量的值 常见错误 1 无法转换类型导致的 javalangIllegalArgumentException 常见错误 2反射非 public 的变量导致的 NoSuchFieldException 常见错误 3 修改 final类型的变量导致的 IllegalAccessException 总结
Java SE(Java Platform, Standard Edition)
m0_64021225的博客
06-09 751
Java SE 学习笔记 基础知识点总结
【JAVA SE】——注解和反射
weixin_43250787的博客
04-08 503
注解和反射
Java:泛型和反射
m0_60388241的博客
05-30 1460
泛型: 在编译阶段检查了类型是否一致,避免了向下转型时类型转换异常 //定义一个泛型类 public class TestMethod <T>{ //只是使用了泛型参数的普通方法 public void testMethod(T t){ System.out.println(t); } /** * 使用了泛型定义的泛型方法, * 泛型方法以自己的类型参数为准, * 与泛型类中的T无关 *..
JAVA SE
举目沧桑的博客
01-11 3024
JAVA SE（Java Platform Standard Edition ,Java标准版） JRE（运行环境）：提供Java虚拟机和运行Java应用程序所必需的类库 JDK(Java SE开发工具集)：包括JRE和命令行开发工具（编译，运行，调试Java程序所需要的基本工具） JRE与JDK的区别： 如果只需要在某种操作系统下运行Java应用程序，则安装支持该操作系统的JRE软件即可； 如果不仅要运行Java应用程序，还要开发Java应用程序，就需要安装支持该操作系统的JDK软件； .
Java Platform SE 8.zip
03-31
Java Platform Standard Edition 8（Java SE 8）是Java编程语言和平台的一个重要版本，它在2014年发布，引入了许多创新功能，极大地增强了开发者的工作效率和代码质量。这个压缩包“Java Platform SE 8.zip”包含了...
Java.SE.Programming.Complete
03-15
Java SE (标准版) 编程是Java语言的核心部分，主要关注桌面应用和服务器端开发。这个"Java.SE.Programming.Complete"项目集包含了在大学学习Java SE编程时可能涉及的所有重要概念和技术。以下是对这些知识点的详细...
Java SE 和 Java Web.zip
06-16
此外，Java SE还包括对多线程、网络编程、I/O流、反射、集合框架等核心功能的支持。Java SE的最新版本通常会引入新的特性和改进，例如Java 8引入了Lambda表达式和函数式编程概念，Java 11引入了HTTP客户端等。 **...
Java se 面试题.docx
06-15
在现代Java中，推荐使用`Enum`来实现线程安全且避免反射攻击的单例： ```java public enum Singleton { INSTANCE; } ``` 总结，Java SE面试题通常涉及广泛的主题，如自增运算的顺序和单例模式的设计，理解这些...
java API SE.zip
01-13
7. **反射API**：`java.lang.reflect`包提供了反射API，允许程序在运行时动态访问和修改类的信息，如创建对象、调用方法、访问字段等。 8. **日期时间API**：Java 8引入了新的日期时间API，如`LocalDate`、`...
南昌航空大学考研17个学院，59个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
07-15
南昌航空大学考研17个学院，59个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
齐齐哈尔医学院考研，57个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
最新发布
07-15
齐齐哈尔医学院考研，57个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
龙年吉祥开门红PPT模板，适用于年度总结，工作总结
07-15
【作品名称】：龙年吉祥开门红PPT模板，适用于年度总结，工作总结 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
SQLServer内存使用分析方法.doc
07-15
数据库

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值