java学习--反射

我与java相爱相杀

于 2024-08-19 23:16:31 发布

阅读量561

点赞数 14

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/qq_56798493/article/details/141164614

版权

前言

示例：

配置文件＋反射实现想要的效果。

注意在使用newInstance（）方法时，不加参数则是默认调用的class类对应的类的无参构造器，所以，相应的类一定要有无参构造器。

反射简介

反射机制允许程序在执行期借助于ReflectionAPI取得任何类的内部信息(比如成员变量,构造器,成员方法等等),并能操作对象的属性及方法。反射在设计模式和框架底层都会用到
加载完类之后,在堆中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以,形象的称之为:反射

原理图：

解析：

源码通过编译得到字节码文件，而字节码文件包括其属性，构造器，成员变量，泛型等等。当我们new了一个对象，那么就会经过了第一阶段编译阶段就来到了加载阶段，会将形成的字节码文件通过类加载器（体现反射机制）到加载阶段，生成了class类对象将其放入堆中，其中包含成员变量，构造器，成员方法等，根据反射机制会将成员变量，构造器，成员方法等分别当做对象来对待。当我们的带class对象可以创建对象，调用其方法，操作其属性。

反射机制可完成的内容

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时得到任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
生成动态代理

反射相关的主要类:

java.lang.Class:代表一个类,Class对象表示某个类加载后在堆中的对象
java.lang.reflect.Method:代表类的方法,Method对象表示某个类的方法
java.lang.reflect.Field:代表类的成员变量,Field对象表示某个类的成员变量
java.lang.reflect.Constructor:代表类的构造方法,Constructor对象表示构造器

这些类在java.lang.reflection

演示：

使用Field类拿属性借助了其方法get（）拿到对象属性，但是值得一提的是，他不可拿非public的属性，否则报错！

还可以用set更改属性。

使用方法类也一样，非public不可使用该类的invoke（）方法获取。

使用构造器类可以指定要调用哪个构造器，不过参数要写对应的构造器的参数的class类，如下图所示：

老师示范：

反射优点和缺点

优点:可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制,框架技术就失去底层支撑。
缺点:使用反射基本是解释执行,对执行速度有影响.

反射调用优化-关闭访问检查

Method和Field、Constructor对象都有setAccessible()方法
setAccessible作用是启动和禁用访问安全检查的开关
参数值为true表示反射的对象在使用时取消访问检查,提高反射的效率。参数值为false则表示反射的对象执行访问检查

m（）方法是未关闭访问检查的，可以看出来比关闭的用时要长

Class类

介绍

Class也是类,因此也继承Object类[类图]
Class类对象不是new出来的,而是系统创建的
对于某个类的Class类对象,在内存中只有一份,因为类只加载一次
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class可以完整地得到一个类的完整结构,通过一系列API
Class对象是存放在堆的
类的字节码二进制数据,是放在方法区的,有的地方称为类的元数据(包括方法代码,变量名,方法名,访问权限等等)https://www.zhihu.com/question/38496907【示意图】

常用方法及应用应用：

获取Class类对象方法

1.前提:已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException,实例:Class cls1=Class.forName( "java.lang.Cat" );
应用场景:多用于配置文件,读取类全路径,加载类.

2.前提:若已知具体的类,通过类的class获取,该方式最为安全可靠,程序性能最高实例:

Class cls2=Cat.class;
应用场景:多用于参数传递,比如通过反射得到对应构造器对象.

3.前提:已知某个类的实例,调用该实例的getClass()方法获取Class对象,实例:
Class clazz=对象.getClass();
应用场景:通过创建好的对象,获取Class对象.

4.其他方式
ClassLoader cl=对象.getClass().getClassLoader();
Class clazz4=cl.loadClass(“类的全类名”);

5.基本数据(int,char,boolean,float,double,byte,long,short)按如下方式得到Class类对象

Class cls=基本数据类型.class

6.基本数据类型对应的包装类,可以通过.type得到Class类对象

Class cls=包装类.TYPE

方法５和方法６获取的基本类型的ｃｌａｓｓ类是同一个

哪些类型有Class对象

外部类,成员内部类,静态内部类,局部内部类,匿名内部类
interface:接口
数组
enum:枚举
annotation:注解
基本数据类型
void

类加载

反射机制是java实现动态语言的关键,也就是通过反射实现类动态加载。

静态加载:编译时加载相关的类,如果没有则报错,依赖性太强
动态加载:运行时加载需要的类,如果运行时不用该类,即使不存在该类,则不报错,降低了依赖性

类加载时机

当创建对象时(new)//静态加载
当子类被加载时,父类也加载//静态加载
调用类中的静态成员时//静态加载
通过反射//动态加载

详解：

例如当写了一段代码如下，当你输入的ｋｅｙ为任何值，到达任何的ｃａｓｅ中，是否用到了创建得Ｄｏｇ类，他都会进行加载，如果不存在Ｄｏｇ类则会报错，而此时，对于Ｄｏｇ类的加载称作静态加载，发生在运行前。如果Ｐｅｒｓｏｎ类不存在，只要ｋｅｙ值不为“２”则代码不会报错，只要不使用，不经过他，就不会对Ｐｅｒｓｏｎ类进行加载，属于动态加载

流程图

其中，验证是对代码安全性验证，比如文件标识符，字节码文件，源数据的验证，准备阶段是对静态数据进行默认的初始化，并分配空间。解析就是把符号引用转成直接引用。初始化由程序员决定的。

加载阶段

JVM 在该阶段的主要目的是将字节码从不同的数据源(可能是class文件、也可能是jar包,甚至网络)转化为二进制字节流加载到内存中,并生成一个代表该类的java.lang.Class 对象

连接阶段-验证

目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求,并且不会危害虚拟机自身的安全。
包括:文件格式验证(是否以魔数oxcafebabe开头)、元数据验证、字节码验证和符号引用验证[举例说明]
可以考虑使用-Xverify:none参数来关闭大部分的类验证措施,缩短虚拟机类加载的时间。

连接阶段-准备

JVM 会在该阶段对静态变量,分配内存并初始化(对应数据类型的默认初始值,如0、OL、null、false等)。这些变量所使用的内存都将在方法区中进行分配

连接阶段-解析

虚拟机将常量池内的符号引用替换为直接引用的过程。

Initialization(初始化)

到初始化阶段,才真正开始执行类中定义的Java程序代码,此阶段是执行<clinit>()方法的过程。
<clinit>()方法是由编译器按语句在源文件中出现的顺序,依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并进行合并。
虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步,如果多个线程同时去初始化一个类,那么只会有一个线程去执行这个类的<clinit>()方法,其他线程都需要阻塞等待,直到活动线程执行<clinit>()方法完毕[debug源码]

通过反射获取信息

package com.reflect_test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
*/public class Main05 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class<?> aClass = Class.forName("com.reflect_test.A");
        System.out.println(aClass.getName());//com.reflect_test.A
        System.out.println(aClass.getSimpleName());//A
        System.out.println(aClass.getPackage());//package com.reflect_test
        //获取类中公有的所有属性
        Field[] fields = aClass.getFields();
        for (Field f:fields)
            System.out.println("公有的所有属性"+f.getName());
        Field[] declaredFields = aClass.getDeclaredFields();
        //获取类中类包括公有的和非公有的
        for (Field f:declaredFields)
            System.out.println("公有和非公有的所有属性"+f.getName());
        //获取该类所有公有的方法，包括其父类的方法，因为每个类都父类object，所以，可以看到很多object的方法
        Method[] method = aClass.getMethods();
        for (Method method1:method)
            System.out.println("公有及其父类的公有方法"+method1.getName());
        //获取本类所有方法，包括公有的和非公有的
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method method1:declaredMethods)
            System.out.println("本类公有与非公有方法"+method1.getName());
        //获取本类所有公有的构造器
        Constructor<?>[] constructors = aClass.getConstructors();
        for (Constructor<?> constructor:constructors)
            System.out.println("本类所有公有的构造器"+constructor.getName());
        //获取本类所有公有的和非公有的构造器
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor constructor:declaredConstructors)
            System.out.println("本类所有公有的和非公有的构造器"+constructor.getName());
        Class<?> superclass = aClass.getSuperclass();
        //返回直接父类接口信息
        System.out.println(superclass);
        Class<?>[] interfaces = aClass.getInterfaces();
        for (Class anINterface:interfaces)
            System.out.println("直接父类接口信息"+anINterface);
        //获取所有注释信息
        Annotation[] annotation = aClass.getAnnotations();
        for (Annotation annotation1:annotation)
            System.out.println("所有注释信息"+annotation1);


    }
}
class AI{}
interface B {

}
interface C{}
class As extends AI {
    public String id;
    public As() {
    }
    public void de(){

    }
    protected void she(){

    }
}
@Deprecated
class A extends As implements B,C{
    public String name;
    private int age;
    protected String sex;

    public A() {
    }
    private A(String name)
    {}

    public A(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public void hi(){
    }
    private void he()
    {}
}

但是只能拿到公有的

公有私有都可以拿到

拿到的本类及父类，包括ｏｂｊｅｃｔ这个父类的方法

package com.reflect_test;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
*/public class Main06 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> aClass = Class.forName("com.reflect_test.R");
        Method[] methods = aClass.getDeclaredMethods();
        for (Method method:methods)
            System.out.println("本类方法名"+method.getName()+"" +
                    "本类方法修饰符的值"+method.getModifiers()+"" +
                    "本类方法返回类型"+method.getReturnType());

    }
}
class R{
    public String name(){
        return null;
    }
    protected int age(){
        return 0;
    }
    private String sex(){
        return null;
    }
    private static final String id()
    {
        return null;


    }
}

通过反射创建对象

方式一:调用类中的public修饰的无参构造器
方式二:调用类中的指定构造器

Class类相关方法
newlnstance:调用类中的无参构造器,获取对应类的对象
getConstructor(Class ... clazz):根据参数列表,获取对应的构造器对象
getDecalaredConstructor(Class ... clazz):根据参数列表,获取对应的构造器对象

Constructor类相关方法
setAccessible:暴破
newlnstance(Object ... obj):调用构造器

package com.reflect_test;

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

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
*/public class Main07 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class<?> aClass = Class.forName("com.reflect_test.User");
        //使用newInstance调用了该类的无参构造器
        Object o = aClass.newInstance();

        //调用参数为String的公共构造器创建class对象
        Constructor<?> constructor = aClass.getConstructor(String.class);
        Object x = constructor.newInstance("小蜜");

        //调用参数为String和int的构造器创建class对象（公共和非公共）,需要使用爆破
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        Object zhuzhu = declaredConstructor.newInstance("zhuzhu", 20);

        System.out.println("方式一"+o+"方式二"+x+"方式三"+zhuzhu);

    }
}
class User{
    private String name="小米";
    private int age=10;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    private User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

因为是非public的构造器，所以无法直接创建实例，需要爆破

爆破--通过反射访问类中的成员

● 访问属性

根据属性名获取Field对象Field f=clazz对象.getDeclaredField(属性名);
暴破:f.setAccessible(true);//f是Field
访问f.set(o,值); syso(f.get(o));
如果是静态属性,则set和get中的参数o,可以写成null

只有静态的才可以置空

● 访问方法

根据方法名和参数列表获取Method方法对象:Method m=clazz.getDeclaredMethod(方法名,XX.class);//得到本类的所有方法
获取对象:Object o=clazz.newlnstance();
暴破:m.setAccessible(true);
访问:Object returnValue=m.invoke(o,实参列表);//o就是对象
注意:如果是静态方法,则invoke的参数o,可以写成null!

可以看出，当方法有返回值，编译类型就为方法的返回类型的类

练习题

package com.reflect_test;

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

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
定义PrivateTest类,有私有name属性,并且属性值为hellokitty
是供getName的公有方法
创建PrivateTest的类,利用Class类得到私有的name属性,修改私有的name属性值,
并调用getName()的方法打印name属性值
*/public class Main09 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //Class<?> aClass = Class.forName("com.reflect_test.PrivateTest");
        Class<PrivateTest> privateTestClass = PrivateTest.class;
        PrivateTest o = privateTestClass.newInstance();
        Field name = privateTestClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"小猫");
        Object getName = privateTestClass.getMethod("getName").invoke(o);
        System.out.println(getName);
    }
}
class PrivateTest{
    private String name="hellokitty";

    public String getName() {
        return name;
    }
}

package com.reflect_test;

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

/*
@author:我与java相爱相杀---c语言梦开始的地方
今天又是努力学习的一天！！！！
利用Class类的forName方法得到File类的class对象
在控制台打印File类的所有构造器
通过newlnstance的方法创建File对象,并创建E:\mynew.txt文件
*/public class Main10 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        Class<?> aClass = Class.forName("java.io.File");
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor constructor:declaredConstructors)
            System.out.println(constructor);
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class);
        Object o = declaredConstructor.newInstance("d:\\mynew.txt");
        Method createNewFile = aClass.getMethod("createNewFile");
        createNewFile.invoke(o);


    }
}

我与java相爱相杀

关注

14
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
java学习--反射

反射机制允许程序在执行期借助于ReflectionAPI取得任何类的内部信息(比如成员变量,构造器,成员方法等等),并能操作对象的属性及方法。反射在设计模式和框架底层都会用到加载完类之后,在堆中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以,形象的称之为:反射Class也是类,因此也继承Object类[类图]Class类对象不是new出来的,而是系统创建的。
复制链接

扫一扫