java基础之反射

最新推荐文章于 2024-08-29 18:44:48 发布

YeungSLee

最新推荐文章于 2024-08-29 18:44:48 发布

阅读量188

点赞数

分类专栏： java 文章标签： java 反射

本文链接：https://blog.csdn.net/weixin_53646515/article/details/119791382

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

java基础之反射

一、类加载器

1.类加载

当程序要使用某个类时，如果该类还未被加载到内存中,则系统会通过类的加载,类的连接,类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化。

类的加载：

就是指将class文件读入内存, 并为之创建一个 java.lang.Class对象
任何类被使用时，系统都会为之建立-个java.lang.Class对象

类的连接：

验证阶段:用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
准备阶段:负责为类的类变量分配内存，并设置默认初始化值
解析阶段:将类的二进制数据中的符号引|用替换为直接引|用

类的初始化：

初始化是对类变量进行的

其步骤：

假如类还未被加载和连接，则程序先加载并连接该类
假如该类的直接父类还未被初始化，则先初始化其直接父类
假如类中有初始化语句，则系统依次执行这些初始化语句

注：在执行第二个步骤的时候，系统会对直接父类初始化步骤，并且也会遵循以上三个步骤。

由此看出，每次初始化，第一个被初始化的都是java.lang.Object。

类初始化的时机：

创建类的实例
调用类的类方法
访问类或者接口的类变量，或者为该类变量赋值
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

2.类加载器

1.类加载器的作用

负责将.class文件加载到内存中，并为之生成对应的java.lang.Class对象
虽然我们不用过分关心类加载的机制，但是了解它可以更好理解程序是怎么运行的。

JVM的类加载机制

全盘负责：当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
父类委托：当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时，才尝试从自己的类路径中加载该类
缓存机制：保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class,只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据,并将其转换成Class对象，存储到缓存区

2.加载器和常见方法

ClassLoader：是负责加载类的对象
Java运行时具有以下内置类加载器

Bootstrap class loader:它是虚拟机的内置类加载器，通常表示为null，并且没有父null
Platform class loader:平台类加载器可以看到所有平台类，平台类包括由平台类加载器或其祖先定义的Java SE平台API,
其实现类和JDK特定的运行时类
System class loader:它也被称为应用程序类加载器，与平台类加载器不同。系统类加载器通常用于定义应用程序类路径,模块路径和JDK特定工具上的类
- 类加载器的继承关系: System的父加载器为Platform,而Platform的父加载器为Bootstrap

ClassLoader中的两个方法：

static ClassLoader getSystemClassLoader():返回用于委派的系统类加载器
ClassLoader getParent):返回父类加载器进行委派

//显示类加载器
public class ClassLoderDemo {
    public static void main(String[] args) {
// static ClassLoader getSystemClassLoader():返回用于委派的系统类加载器
        ClassLoader c1 = ClassLoader.getSystemClassLoader();
        System.out.println(c1);//AppClassLoader

// ClassLoader getParent):返回父类加载器进行委派
        ClassLoader c2 = c1.getParent();
        System.out.println(c2);//ExtClassLoader       ---jdk8返回的是这个
                               //PlatformClassLoader  ---jdk9返回这个
        ClassLoader c3 = c2.getParent();
        System.out.println(c3);//null
    }
}

二、反射

1.引入概念

反射是指什么？

首先引入一个例子，人在走过x光机的时候，我们能扫描出一个人的模样出来。而这个被扫描的图像可以透射出原来的人在哪些部分坏了，那些地方不好，从而可以指导我们到原来那个人那里进行手术操作。

在我们程序中也是这样，

在这里插入图片描述

左边两个类可以看作是人，而这个类加载器就是一台x光机，右边的那个东西就是我们x光机照出来的。类的所有的成员变量，构造方法成员方法都是通过这个Class来使用的。

所以其实我们平时使用类的时候，不是去使用这个类本身，而是通过反射这个方法把类的东西都交给了这个class这个东西来使用。

2.Java反射机制概述：

**Java反射机制：**是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性,可以极大的增强程序的灵活性,程序不用在编译期就完成确定，在运行期仍然可以扩展

获取Class类的对象：

我们要想通过反射去使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象
这里我们提供三种方式获取Class类型的对象

使用类的class属性来获取该类对应的Class对象。举例: Student.class将会返回Student类对应的Class对象
调用对象的getClass(方法, 返回该对象所属类对应的Class对象
该方法是Object类中的方法，所有的Java对象都可以调用该方法
使用Class类中的静态方法forName(String className),该方法需要传入字符串参数,该字符串参数的值是某个类的全路径，也就是完整包名的路径

//获取class对象
public class ClassLoderDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的Class对象。 举例: Student.class将 会返回Student类对应的Class对象
        Class<ClassStudent> c1 = ClassStudent.class;
        System.out.println(c1);
        //class com.lys.heima.javaSEjichu.ClassLoder.ClassStudent

        Class<ClassStudent> c2 = ClassStudent.class;
        System.out.println(c1==c2);
        //调用对象的getClass(方法, 返回该对象所属类对应的Class对象
        //该方法是Object类中的方法，所有的Java对象都可以调用该方法
        Class<? extends ClassStudent> c3 = new ClassStudent().getClass();
        System.out.println(c1==c3);

        //使用Class类中的静态方法forName(String className),该方法需要传入字符串参数,
        // 该字符串参数的值是某个类的全路径，也就是完整包名的路径
        Class<?> C4 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");
        System.out.println(c1==C4);
    }
}
/*
结果：
class com.lys.heima.javaSEjichu.ClassLoder.ClassStudent
true
true
true
*/

3.反射获取构造方法并使用

Class类中用于获取构造方法的方法：

Constructor<?>()getConstructors0:
- 返回所有公共构造方法对象的数组
Constructor<?>() getDeclared onstructors0:
- 返回所有构造方法对象的数组
Constructor getConstructor(Class<?>… parameterTypes):
- 返回单个公共构造方法对象
Constructor getDeclaredConstructor(Class <?> … parameterTypes):
- 返回单个构造方法对象

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;

//通过反射获取构造方法
public class classLoderDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<?> c1 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");
        //获取公共构造方法集
        Constructor<?>[] cons1 = c1.getConstructors();
        for (Constructor c : cons1) {
            System.out.println(c);
        }
        //结果：
        //public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent(java.lang.String,int,java.lang.String)
        //public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent()

        System.out.println("----------------------------------------");
        //获取所有构造方法集
        Constructor<?>[] cons2 = c1.getDeclaredConstructors();
        for (Constructor c : cons2) {
            System.out.println(c);
        }
        //结果：
        //public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent(java.lang.String,int,java.lang.String)
        //com.lys.heima.javaSEjichu.ClassLoder.ClassStudent(java.lang.String,int)
        //private com.lys.heima.javaSEjichu.ClassLoder.ClassStudent(java.lang.String)
        //public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent()

        System.out.println("----------------------------------------");
        //获取单个公共构造方法；
        Constructor<?> con1 = c1.getConstructor();
        System.out.println(con1);
        //public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent()

        System.out.println("----------------------------------------");
        //获取单个构造方法：
        Constructor<?> con2 = c1.getDeclaredConstructor();
        System.out.println(con2);
        //public com.lys.heima.javaSEjichu.ClassLoder.ClassStudent()

        System.out.println("----------------------------------------");
        //通过获取到的构造方法来创建对象
        Object newture = con1.newInstance();//若要调用带参构造方法，括号需要写入参数。
        System.out.println(newture);
        //ClassStudent{name='null', age=0, address='null'}   ;由于classStudent类里重写了tostring方法，所以这里以这种方式输出了。
        System.out.println("----------------------------------------");
        //通过获取到的公共带参构造方法创建对象。
        Constructor<?> con3 = c1.getConstructor(String.class, int.class, String.class);//参数根据顺序排列。要用参数的.class
        Object newInstance = con3.newInstance("陈奕迅", 45, "香港");
        System.out.println(newInstance);
        //ClassStudent{name='陈奕迅', age=45, address='香港'}
    }
}

基础数据类型也可以通过.Class得到对应的Class类型

通过反射利用私有构造方法创建对象：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//反射获取私有构造方法
public class classLoderDemo3 {
    public static void main(String[] args) throws ClassNotFoundException,
     NoSuchMethodException, InvocationTargetException, 
     InstantiationException, IllegalAccessException {
        Class<?> c1 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");
        Constructor<?> con1 = c1.getDeclaredConstructor(String.class);

        //使用暴力反射。将其访问检查取消
        con1.setAccessible(true);//true时表示取消检查

        Object newInstance = con1.newInstance("张家辉");
        //.IllegalAccessException，私有构造方法无法直接使用。
        
        System.out.println(newInstance);
        //ClassStudent{name='张家辉', age=0, address='null'}    通过暴力反射创建成功。
    }
}

public void setAccessible(boolean flag)：值为true ，取消访问检查。

4.通过反射获取成员变量

Class类中用于获取成员变量的方法

Field[ getFields():返回所有公共成员变量对象的数组
Field[ getDeclaredFields():返回所有成员变量对象的数组
Field getField(String name):返回单个公共成员变量对象
Field getDeclaredField(String name):返回单个成员变量对象

Field类中用于给成员变量赋值的方法

void set(Object obj, Object value):给obj对象的成员变量赋值为value

package com.lys.heima.javaSEjichu.ClassLoder;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

//反射获取成员变量并使用
public class classLoderDemo4 {
    public static void main(String[] args) throws ClassNotFoundException,
     NoSuchFieldException,  NoSuchMethodException, InvocationTargetException, 
     InstantiationException, IllegalAccessException {
        Class<?> c1 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");
        //获取所有成员变量
        Field[] fs1 = c1.getDeclaredFields();
        for ( Field  f  : fs1 ){
            System.out.println(f);
        }
        //private java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.name
        //int com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.age
        //public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.address

        System.out.println("--------------------");
        //获取公共成员变量集
        Field[] fs2 = c1.getFields();
        for ( Field  f  : fs2 ){
            System.out.println(f);
        }

        //获取某个公共成员变量
        Field address = c1.getField("address");
        //public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.address

        System.out.println(address);
        //获取任意成员变量
        Field age = c1.getDeclaredField("age");
        System.out.println(age);
        //int com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.age

        //创建一个对象并为其赋值
        Constructor<?> con1 = c1.getConstructor();
        Object obj = con1.newInstance();

        address.set(obj,"香港");
        System.out.println(obj);//ClassStudent{name='null', age=0, address='香港'}

        age.set(obj,15);
        System.out.println(obj);//ClassStudent{name='null', age=15, address='香港'}

        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);//暴力反射，取消访问检查

        name.set(obj,"陈奕迅");
        System.out.println(obj);//ClassStudent{name='陈奕迅', age=15, address='香港'}

        System.out.println(name);/*private java.lang.String 
        com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.name*/

    }

}

5.获取成员方法

Class类中用于获取成员方法的方法

Method[] getMethods():返回所有公共成员方法对象的数组,包括继承的
Method[] getDeclaredMethods():返回所有成员方法对象的数组,不包括继承的
Method getMethod(String name, Class <?>… parameterTypes) :返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>… parameterTypes):返回单个成员方法对象

Method类中用于调用成员方法的方法

Object invoke(Object obj, Object… args):调用obj对象的成员方法,参数是args,返回值是Object类型。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

//获取成员方法
public class classLoderDemo5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<?> c1 = Class.forName("com.lys.heima.javaSEjichu.ClassLoder.ClassStudent");

        //获取公共方法集
        Method[] ms1 = c1.getMethods();  //包含本类公共方法和继承的超类和超接口方法。
        for ( Method m:ms1){
            System.out.println(m);
        }//结果：
        //public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.toString()
        //public void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method1()
        //public void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method2(java.lang.String)
        //public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method3(java.lang.String,int)
        //public final void java.lang.Object.wait() throws java.lang.InterruptedException
        //public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
        //public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
        //public boolean java.lang.Object.equals(java.lang.Object)
        //public native int java.lang.Object.hashCode()
        //public final native java.lang.Class java.lang.Object.getClass()
        //public final native void java.lang.Object.notify()
        //public final native void java.lang.Object.notifyAll()
        System.out.println("------------------");

        //获取所有方法集
        Method[] ms2 = c1.getDeclaredMethods();//包含本来所以方法，但没有继承来的方法。
        for (Method m:ms2){
            System.out.println(m);
        }
        //public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.toString()
        //private void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.function()
        //public void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method1()
        //public java.lang.String com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method3(java.lang.String,int)
        //public void com.lys.heima.javaSEjichu.ClassLoder.ClassStudent.method2(java.lang.String)
        //获取某个公共方法
        Method m1 = c1.getMethod("method1");
        System.out.println(m1);
        Method m2 = c1.getMethod("method3", String.class, int.class);
        //获取任一方法
        Method m3 = c1.getDeclaredMethod("function");
        System.out.println(m2);
        System.out.println("-----------");
        //创建对象，并调用方法
        Constructor<?> con1 = c1.getConstructor();
        Object obj = con1.newInstance();
        m1.invoke(obj); //参数是对象，这样表示是m1被obj对象使用。运行结果：method
        System.out.println("-----------");

        System.out.println(m2.invoke(obj,"张敬轩",15));//张敬轩,15
        System.out.println("-----------");
        m3.setAccessible(true); //设置访问检查取消
        m3.invoke(obj);     //function
    }
}

6.反射练习：

1.有一个ArrayList集合，要在这个集合添加一个字符串数据。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

//在integer集合存字符串
public class ClassLoderDemo6 {
    public static void main(String[] args) throws NoSuchMethodException,
     InvocationTargetException, InstantiationException, IllegalAccessException {
        ArrayList<Integer> a = new ArrayList<>();
        a.add(10);

        Class<? extends ArrayList> c1 = a.getClass();
        Method m = c1.getMethod("add", Object.class);
        m.invoke(a,"hello");
        System.out.println(a);
    }
}

2.通过配置文件运行类中方法：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

//"com.lys.heima.javaSEjichu.ClassLoder.ClassStudent"
public class ClassLoderDemo7 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {

        Properties pro = new Properties();//数据安全的map
        FileReader fr = new FileReader("wenjian.txt");//io流对象去读取文件数据

        pro.load(fr);//把数据传给这个集合
        fr.close();//取完数据关闭资源
        String className = pro.getProperty("className");    //根据键取值
        //System.out.println(className);
        String methodName = pro.getProperty("methodName"); //根据键取值
        //System.out.println(methodName);

        //通过反射使用
        Class<?> c1 = Class.forName(className);  //根据值创建class对象
        Object obj = c1.newInstance();  //根据类创建新对象。
        Method method = c1.getMethod(methodName);//根据值创建方法对象
        method.invoke(obj);     //调用方法

    }
}
/*
结果：
method
*/


wenjian.txt:
className=com.lys.heima.javaSEjichu.ClassLoder.ClassStudent
methodName=method1


以上代码其实是根据这个wenjian.txt里面的键值对来反射出对象并进行操作的，
这意味着，我只需要更改文件里的内容，就可以让我同一份代码完成不同的操作。
这就体现出了反射的灵活性了。

最后总结：到底什么是反射？反射就是将类的各个部分（成员，方法，构造器）封装成对象。

YeungSLee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java基础之反射

java基础之反射一、类加载器1.类加载当程序要使用某个类时，如果该类还未被加载到内存中,则系统会通过类的加载,类的连接,类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化。类的加载：就是指将class文件读入内存, 并为之创建一个 java.lang.Class对象任何类被使用时，系统都会为之建立-个java.lang.Class对象类的连接：验证阶段:用于检验被加载的类是否有正确的内部结构，并和其他
复制链接

扫一扫