首页 > 编程语言 >科普文:Java基础系列之【你必须知道的框架基础-反射/代理】

科普文:Java基础系列之【你必须知道的框架基础-反射/代理】

时间:2024-08-12 14:52:05浏览次数:14  
标签:Java class 基础 System public println out Class 科普

前言

科普文:Java基础系列之【Java动态代理的应用场景和基本原理 】-CSDN博客

科普文:Java基础系列之【字节码增强技术探索】-CSDN博客

科普文:Java基础系列之【字节码应用案例Fastjson原理和实操说明】-CSDN博客

科普文:Java基础系列之【JVM 字节码操作 ASM 框架概叙】-CSDN博客

科普文:Java基础系列之【java动态代理基本原理及proxy源码分析五】-CSDN博客

科普文:Java基础系列之[java动态编译]-CSDN博客

科普文:Java基础系列之深入理解Java注解、反射与代理机制-CSDN博客

Java的反射(reflection)机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一个对象所属的类,可以了解任意一个类的成员变量和方法,可以调用任意一个对象的属性和方法。

这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。

Java反射是指在运行时动态加载类并操作其属性和方法的能力。前面的文章都有提到反射,反射是这些框架和功能的基础,今天我们详细讲解反射。

Java反射机制是在程序的运行过程中,对于任何一个类,都能够知道它的所有属性和方法;对于任意一个对象,都能够知道它的任意属性和方法,这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

Java反射机制主要提供以下这几个功能:

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所有的成员变量和方法
  • 在运行时调用任意一个对象的方法

在Java中,反射和代理是两种强大的工具,可以在运行时操作类和对象。

反射是基础,通过反射获取对象及其属性和操作;代理则可以将反射出来的类包装成目标类,然后构建一个代理类,通过代理类来操控目标类。后面我们再讲代理。

反射引出

一个需求

根据配置文件 re.properties 指定信息,创建 Cat 对象并调用方法 hi

classfullpath=com.jwt.Cat
method=hi

这样的需求在学习框架时很多,即在通过外部文件配置,在不修改源码的情况下,来控制程序

传统方法

传统的方法是先 new 一个对象,然后再调用它的方法。

Cat cat = new Cat();
cat.hi();

通过传统方法,确实可以调用 hi() 方法,但是这和我们的需求不一样,这里我们是要根据配置文件 re.properties 指定信息来完成。可以使用 Properties 来读取配置文件。

Properties properties = new Properties();
properties.load(new FileInputStream("src//re.properties"));
String classfullpath = properties.getProperty("classfullpath");//"com.jwt.Cat"
String methodName = properties.getProperty("method");//"hi"
System.out.println("classfullpath=" + classfullpath);
System.out.println("method=" + methodName);

然后需要创建对象,怎么创建对象呢?直接new classfullpath,这样不就好了嘛?

嗯,想法不错,下回不要想了。

现在的 classfullpath 可是字符串类型,怎么能去new呢。所以现有技术是做不到这个事情的。

那么这里就要引入我们要将的重点——反射机制。

反射方法

public class ReflectionQuestion {
    public static void main(String[] args) throws Exception {
        //1. 使用Properties 类, 可以读取配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src//re.properties"));
        String classfullpath = properties.getProperty("classfullpath");//"com.jwt.Cat"
        String methodName = properties.getProperty("method");//"hi"
        System.out.println("classfullpath=" + classfullpath);
        System.out.println("method=" + methodName);
      
        //2. 使用反射机制解决
        //(1) 加载类, 返回Class类型的对象cls
        Class cls = Class.forName(classfullpath);
        System.out.println("cls = " + cls);
        //(2) 通过cls得到你加载的类com.jwt.Cat的对象实例
        Object o = cls.newInstance();
        System.out.println("o 的运行类型=" + o.getClass()); //运行类型
        //(3) 通过cls得到你加载的类com.jwt.Cat的methodName "hi" 的方法对象
        Method method = cls.getMethod(methodName);
        //(4) 通过method 调用方法: 即通过方法对象来实现调用方法
        method.invoke(o); //传统方法对象.方法() , 反射机制:方法.invoke(对象)
    }
}

反射机制还有一个优点,那就是可以通过外部文件配置,在不修改源码的情况下,来控制程序。

比如这里,我在Cat 类下面再写一个方法,cry()方法,

如果我们使用传统方法,要调用这个方法,是不是就要修改代码了,比如cat.cry();

通过反射,只需在配置文件 re.properties 中,将 method=hi 改为 method=cry 就可以了。

反射是什么

简介

  • 反射机制允许程序在执行时借助于 Reflection API 取得任何类的内部信息(比如成员变量,构造器,成员方法等等),并能操作对象的属性及方法。
  • 在运行状态中,对象可以通过反射获取他的类,类可以通过反射拿到所有⽅法(包括私有),拿到的⽅法可以调⽤,总之通过“反射”,我们可以将Java这种静态语⾔附加上动态特性。
  • 加载完类之后,在堆中就产生了一个 Class 类型的对象(一个类只有一个Class对象) ,这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个 Class 对象就像一面镜子,透过这个镜子看到类的结构,所以,形象的称之为反射

一句话总结:反射就是在运行时才知道要操作的类是什么,并且可以在运行时获取类的完整构造,并调用对应的方法。动态特性

反射机制原理示意

反射机制可以完成

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

反射相关的主要类

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

import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;

public class Reflection01 {
    public static void main(String[] args) throws Exception {
        //1. 使用Properties 类, 可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src//re.properties"));
        String classfullpath = properties.get("classfullpath").toString();
        String methodName = properties.get("method").toString();
        //2. 使用反射机制解决
        //(1) 加载类, 返回Class 类型的对象cls
        Class cls = Class.forName(classfullpath);
        //(2) 通过cls 得到你加载的类com.hspedu.Cat 的对象实例
        Object o = cls.newInstance();
        System.out.println("o 的运行类型=" + o.getClass()); //运行类型
        //java.lang.reflect.Method:代表类的方法,Method 对象表示某个类的方法
        Method method = cls.getMethod(methodName);
        //通过method 调用方法: 即通过方法对象来实现调用方法
        method.invoke(o);

        //java.lang.reflect.Field: 代表类的成员变量, Field 对象表示某个类的成员变量
        //getField 不能得到私有的属性
        Field nameField = cls.getField("name");
        System.out.println(nameField.get(o)); // 传统写法对象.成员变量, 反射: 成员变量对象.get(对象)

        //java.lang.reflect.Constructor: 代表类的构造方法, Constructor 对象表示构造器
        Constructor constructor = cls.getConstructor(); //()中可以指定构造器参数类型, 返回无参构造器
        System.out.println(constructor);//Cat()
        Constructor constructor2 = cls.getConstructor(String.class); //这里传入的String.class 就是String 类的Class 对象
        System.out.println(constructor2);//Cat(String name)
    }
}

反射优点和缺点

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

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

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

import com.jwt.Cat;
import java.lang.reflect.Method;

public class Reflection02 {
    public static void main(String[] args) throws Exception {
        m1();//传统
        m2();//反射
        m3();//反射优化
    }

    //传统方法来调用hi
    public static void m1() {
        Cat cat = new Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            cat.hi();
        }
        long end = System.currentTimeMillis();
        System.out.println("m1() 耗时=" + (end - start)+"ms");
    }


    //反射机制调用方法hi
    public static void m2() throws Exception {
        Class cls = Class.forName("com.jwt.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            hi.invoke(o);//反射调用方法
        }
        long end = System.currentTimeMillis();
        System.out.println("m2() 耗时=" + (end - start)+"ms");
    }

    //反射调用优化+ 关闭访问检查
    public static void m3() throws Exception {
        Class cls = Class.forName("com.jwt.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        hi.setAccessible(true);//在反射调用方法时,取消访问检查
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            hi.invoke(o);//反射调用方法
        }
        long end = System.currentTimeMillis();
        System.out.println("m3() 耗时=" + (end - start)+"ms");
    }
}
/**
m1() 耗时=2ms
m2() 耗时=934ms
m3() 耗时=769ms
**/

Class 类

基本介绍

  1. Class 也是类,继承 Object 类
  2. Class 类对象不是 new 出来的,而是系统创建的
  3. 对于某个类的 Class 类对象,在内存中只有一份,因为类只加载一 次
  4. 每个类的实例都会记得自己是由哪个 Class 实例所生成
  5. 通过 Class 对象可以完整地得到一个类的完整结构
  6. Class 对象是存放在堆的,类的字节码二进制数据, 是放在方法区的,有的地方称为类的元数据(包括方法代码,变量名,方法名,访问权限等等)

Class类的常用方法

方法名功能说明
static Class forName(String name)返回指定类名name的Class对象
object newlnstance()调用缺省构造函数,返回该Class对象的一个实例
getName()返回此Class对象所表示的实体(类、接口、数组类、基本类型等)名称
Class [] getInterfaces()获取当前Class对象的接口
ClassLoader getClassLoader()返回该类的类加载器
Class getSuperclass()返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors()返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields()返回Field对象的一个数组
Method getMethod(String name,Class…<?> paramTypes)返回一个Method对象,此对象的形参类型为paramType
package com.jwt.reflection;

import java.lang.reflect.Field;

public class Class02 {
    public static void main(String[] args) throws Exception {
        String classAllPath = "com.jwt.reflection.Car";
        //1 . 获取到Car 类对应的Class 对象
        Class<?> cls = Class.forName(classAllPath);//<?> 表示不确定的Java 类型
        //2. 输出cls
        System.out.println(cls); //显示cls 对象, 是哪个类的Class 对象
        System.out.println(cls.getClass());//输出cls 运行类型java.lang.Class
        //3. 得到包名
        System.out.println(cls.getPackage().getName());//包名
        //4. 得到全类名
        System.out.println(cls.getName());
        //5. 通过cls 创建对象实例
        Car car = (Car) cls.newInstance();
        System.out.println(car);//car.toString()
        //6. 通过反射获取属性brand
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));//宝马
        //7. 通过反射给属性赋值
        brand.set(car, "奔驰");
        System.out.println(brand.get(car));//奔驰
        //8. 得到所有的属性(字段)
        System.out.println("=======所有的字段属性====");
        Field[] fields = cls.getFields();
        for (Field f : fields) {
            System.out.println(f.getName());//名称
        }
    }

}

class Car {
    public String brand = "宝马";
    public int price = 500000;
    public String color = "白色";

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", color='" + color + '\'' +
                '}';
    }
}

/**
class com.jwt.reflection.Car
class java.lang.Class
com.jwt.reflection
com.jwt.reflection.Car
Car{brand='宝马', price=500000, color='白色'}
宝马
奔驰
=======所有的字段属性====
brand
price
color
**/

获取Class类对象

1、Class.forName

前提:已知一个类的全名称,且该类路径下,可通过 Class 类的静态方法 forName() 获取,可能抛出ClassNotFoundException 异常

实例:Class cls1 = Class.forName(“java.lang.Cat”);

应用场景:多用于配置文件,读取类全路径,加载类

2、类名.class

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

实例:Class cls2 = Car.class;

应用场景:多用于参数传递,比如通过反射得到对应构造器对象

3、对象.getClass()

前提:已知某个类的实例,调用该实例的 getClass() 方法获取 Class 对象

实例:Class cls3 = 对象.getClass();//运行类型

应用场景:通过创建好的对象,获取 Class 对象

4、通过类加载器

ClassLoader classLoader = 对象.getClass().getClassLoader();
Class cls4 = classLoader.loadClass(“类的全类名”);

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

Class cls5 = 基本数据类型.class

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

Class cls6 = 包装类.TYPE
package com.jwt.reflection;

public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {
        //1. Class.forName
        String classAllPath = "com.jwt.reflection.Car"; //通过读取配置文件获取
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);
        //2. 类名.class , 应用场景: 用于参数传递
        Class cls2 = Car.class;
        System.out.println(cls2);
        //3. 对象.getClass(), 应用场景,有对象实例
        Car car = new Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);
        //4. 通过类加载器【4 种】来获取到类的Class 对象
        //(1)先得到类加载器car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class 对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);
        //5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到Class 类对象
        Class<Integer> cls5 = int.class;
        System.out.println(cls5);//int
        //6. 基本数据类型对应的包装类,可以通过.TYPE 得到Class 类对象
        Class<Integer> cls6 = Integer.TYPE;
        System.out.println(cls6);
    }
}
/**
class com.jwt.reflection.Car
class com.jwt.reflection.Car
class com.jwt.reflection.Car
class com.jwt.reflection.Car
int
int
**/

哪些类型有Class对象

  1. 外部类,成员内部类,静态内部类,局部内部类,匿名内部类
  2. interface:接口
  3. 数组
  4. enum:枚举
  5. annotation:注解
  6. 基本数据类型
  7. void
package com.jwt.reflection;

import java.io.Serializable;

public class AllTypeClass {
    public static void main(String[] args) {
        Class<String> aClass1 = String.class;//外部类
        Class<Serializable> aClass2 = Serializable.class;//接口
        Class<Integer[]> aClass3 = Integer[].class;//数组
        Class<Integer[][]> aClass4 = Integer[][].class;//二维数组
        Class<Deprecated> aClass5 = Deprecated.class;//注解
        Class<Thread.State> aClass6 = Thread.State.class;//枚举
        Class<Long> aClass7 = long.class;//基本数据类型
        Class<Void> aClass8 = void.class;//void数据类型
        Class<Class> aClass9 = Class.class;//Class类

        System.out.println(aClass1);
        System.out.println(aClass2);
        System.out.println(aClass3);
        System.out.println(aClass4);
        System.out.println(aClass5);
        System.out.println(aClass6);
        System.out.println(aClass7);
        System.out.println(aClass8);
        System.out.println(aClass9);
    }
}

类加载

静态加载和动态加载

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

  • 静态加载:编译时加载相关的类,如果没有则报错
Dog dog = new Dog();
  • 动态加载:运行时加载需要的类,编译不报错,降低了依赖性
Class cls = Class.forName("Person");
Object o = cls.newInstance();
Method method = cls.getMethod("hi");
method.invoke(o);

类加载时机

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

类加载过程图

类加载各阶段完成任务

类加载五个阶段

1、加载阶段

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

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

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

class A {
//分析类加载的链接阶段-准备属性是如何处理
//1. n1 是实例属性, 不是静态变量,因此在准备阶段,是不会分配内存
//2. n2 是静态变量,分配内存n2 默认初始化0 ,而不是20
//3. n3 是static final 是常量, 他和静态变量不一样, 因为一旦赋值就不变n3 = 30
public int n1 = 10;
public static int n2 = 20;
public static final int n3 = 30;
}
4、连接阶段——解析

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

5、初始化阶段

到初始化阶段,才真正开始执行类中定义的 Java 程序代码,此阶段是执行()方法的过程

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

反射获取类的结构信息

1、java.lang.Class类

  • getName:获取全类名
  • getSimpleName:获取简单类名
  • getFields:获取所有public修饰的属性,包含本类以及父类的
  • getDeclaredFields:获取本类中所有属性
  • getMethods:获取所有public修饰的方法,包含本类以及父类的
  • getDeclaredMethods:获取本类中所有方法
  • getConstructors:获取所有public修饰的构造器,包含本类以及父类的
  • getDeclaredConstructors:获取本类中所有构造器
  • getPackage:以Package形式返回父类信息
  • getSuperClass:以Class形式返回父类信息
  • getInterfaces:以Class[]形式返回接口信息
  • getAnnotations:以Annotation[]形式返回注解信息
@Test
public void api_01() throws ClassNotFoundException, NoSuchMethodException {
    //得到Class 对象
    Class<?> personCls = Class.forName("com.jwt.reflection.Person");

    //getName:获取全类名
    System.out.println(personCls.getName());//com.hspedu.reflection.Person
    //getSimpleName:获取简单类名
    System.out.println(personCls.getSimpleName());//Person
    //getFields:获取所有public 修饰的属性,包含本类以及父类的
    Field[] fields = personCls.getFields();
    for (Field field : fields) {//增强for
      System.out.println("本类以及父类的属性=" + field.getName());
    }
    System.out.println("==========================");
    //getDeclaredFields:获取本类中所有属性
    Field[] declaredFields = personCls.getDeclaredFields();
    for (Field declaredField : declaredFields) {
      System.out.println("本类中所有属性=" + declaredField.getName());
    }
    System.out.println("==========================");
    //getMethods:获取所有public 修饰的方法,包含本类以及父类的
    Method[] methods = personCls.getMethods();
    for (Method method : methods) {
      System.out.println("本类以及父类的方法=" + method.getName());
    }
    System.out.println("==========================");
    //getDeclaredMethods:获取本类中所有方法
    Method[] declaredMethods = personCls.getDeclaredMethods();
    for (Method declaredMethod : declaredMethods) {
      System.out.println("本类中所有方法=" + declaredMethod.getName());
    }
    System.out.println("==========================");
    //getConstructors: 获取所有public 修饰的构造器,包含本类
    Constructor<?>[] constructors = personCls.getConstructors();
    for (Constructor<?> constructor : constructors) {
      System.out.println("本类的构造器=" + constructor.getName());
    }
    System.out.println("==========================");
    //getDeclaredConstructors:获取本类中所有构造器
    Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
    for (Constructor<?> declaredConstructor : declaredConstructors) {
      System.out.println("本类中所有构造器=" + declaredConstructor.getName());//这里老师只是输出名
    }
    System.out.println("==========================");
    //getPackage:以Package 形式返回包信息
    System.out.println(personCls.getPackage());//com.hspedu.reflection
    //getSuperClass:以Class 形式返回父类信息
    Class<?> superclass = personCls.getSuperclass();
    System.out.println("父类的class 对象=" + superclass);
    System.out.println("==========================");
    //getInterfaces:以Class[]形式返回接口信息
    Class<?>[] interfaces = personCls.getInterfaces();
    for (Class<?> anInterface : interfaces) {
      System.out.println("接口信息=" + anInterface);
    }
    System.out.println("==========================");
    //getAnnotations:以Annotation[] 形式返回注解信息
    Annotation[] annotations = personCls.getAnnotations();
    for (Annotation annotation : annotations) {
      System.out.println("注解信息=" + annotation);//注解
    }
}
/**
com.jwt.reflection.Person
Person
本类以及父类的属性=name
本类以及父类的属性=hobby
==========================
本类中所有属性=name
本类中所有属性=age
本类中所有属性=job
本类中所有属性=sal
==========================
本类以及父类的方法=m1
本类以及父类的方法=hi
本类以及父类的方法=wait
本类以及父类的方法=wait
本类以及父类的方法=wait
本类以及父类的方法=equals
本类以及父类的方法=toString
本类以及父类的方法=hashCode
本类以及父类的方法=getClass
本类以及父类的方法=notify
本类以及父类的方法=notifyAll
==========================
本类中所有方法=m1
本类中所有方法=m2
本类中所有方法=m4
本类中所有方法=m3
==========================
本类的构造器=com.jwt.reflection.Person
本类的构造器=com.jwt.reflection.Person
==========================
本类中所有构造器=com.jwt.reflection.Person
本类中所有构造器=com.jwt.reflection.Person
本类中所有构造器=com.jwt.reflection.Person
==========================
package com.jwt.reflection
父类的class 对象=class com.jwt.reflection.A
==========================
接口信息=interface com.jwt.reflection.IA
接口信息=interface com.jwt.reflection.IB
==========================
**/

测试代码

class A {
    public String hobby;
    public void hi() {}
    public A() {}
    public A(String name) {}
}


interface IA { }

interface IB { }

@Deprecated
class Person extends A implements IA, IB {
    //属性
    public String name;
    protected static int age; // 4 + 8 = 12
    String job;
    private double sal;
    //构造器
    public Person() {}
    public Person(String name) {}
    //私有的
    private Person(String name, int age) {}
    //方法
    public void m1(String name, int age, double sal) {}
    protected String m2() {
        return null;
    }
    void m3() {}
    private void m4() {}
}

2、java.lang.reflect.Field类

  • getModifiers:以int形式返回修饰符
    • 说明:默认修饰符是0,public是1,private是2,protected是4,static是8,final是16
  • getType:以Class形式返回类型
  • getName:返回属性名

3、java.lang.reflect.Mehod类

  • getModifiers:以int形式返回修饰符
    • 说明:默认修饰符是0,public是1,private是2,protected是4,static是8,final是16
  • getReturnType:以Class形式获取返回类型
  • getName:返回方法名
  • getParameterTypes:以Class[]返回参数类型数组

4、java.lang.reflect.Constructor类

  • getModifiers:以int形式返回修饰符
  • getName:返回构造器名(全类名)
  • getParameterTypes:以Class[]返回参数类型数组
@Test
public void api_02() throws ClassNotFoundException, NoSuchMethodException {
  //得到Class 对象
  Class<?> personCls = Class.forName("com.jwt.reflection.Person");
  
  //java.lang.reflect.Field
  //规定说明: 默认修饰符是0 , public 是1 ,private 是2 ,protected 是4 , static 是8 ,final 是16
  Field[] declaredFields = personCls.getDeclaredFields();
  for (Field declaredField : declaredFields) {
    System.out.println("本类中所有属性=" + declaredField.getName()
                       + " 该属性的修饰符值=" + declaredField.getModifiers()
                       + " 该属性的类型=" + declaredField.getType()
                      );
  }
  System.out.println("==========================");

  //java.lang.reflect.Mehod
  Method[] declaredMethods = personCls.getDeclaredMethods();
  for (Method declaredMethod : declaredMethods) {
    System.out.println("本类中所有方法=" + declaredMethod.getName()
                       + " 该方法的访问修饰符值=" + declaredMethod.getModifiers()
                       + " 该方法返回类型" + declaredMethod.getReturnType()
                      );
  }
  for (Method declaredMethod : declaredMethods) {
    //输出当前这个方法的形参数组情况
    Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
    for (Class<?> parameterType : parameterTypes) {
      System.out.println("该方法的形参类型=" + parameterType);
    }
  }
  System.out.println("==========================");


  //java.lang.reflect.Constructor
  Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
  for (Constructor<?> declaredConstructor : declaredConstructors) {
    System.out.println("本类中所有构造器=" + declaredConstructor.getName());//只是输出名

  }
  for (Constructor<?> declaredConstructor : declaredConstructors) {
    Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
    for (Class<?> parameterType : parameterTypes) {
      System.out.println("该构造器的形参类型=" + parameterType);
    }
  }
}
/**
本类中所有属性=name 该属性的修饰符值=1 该属性的类型=class java.lang.String
本类中所有属性=age 该属性的修饰符值=12 该属性的类型=int
本类中所有属性=job 该属性的修饰符值=0 该属性的类型=class java.lang.String
本类中所有属性=sal 该属性的修饰符值=2 该属性的类型=double
==========================
本类中所有方法=m1 该方法的访问修饰符值=1 该方法返回类型void
本类中所有方法=m2 该方法的访问修饰符值=4 该方法返回类型class java.lang.String
本类中所有方法=m4 该方法的访问修饰符值=2 该方法返回类型void
本类中所有方法=m3 该方法的访问修饰符值=0 该方法返回类型void
该方法的形参类型=class java.lang.String
该方法的形参类型=int
该方法的形参类型=double
==========================
本类中所有构造器=com.jwt.reflection.Person
本类中所有构造器=com.jwt.reflection.Person
本类中所有构造器=com.jwt.reflection.Person
该构造器的形参类型=class java.lang.String
该构造器的形参类型=int
该构造器的形参类型=class java.lang.String
**/

反射创建对象

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

Class类相关方法

  • newInstance() 调用类中的无参构造器,获取对应类的对象
  • getConstructor(Class..clazz) 根据参数列表,获取对应的public构造器对象
  • getDecalaredConstructor(Class.cazz) 根据参数列表,获取对应的所有构造器对象

Constructor类相关方法

  • setAccessible:爆破(形参填入true,即可访问私有构造方法、变量、方法等)
  • newInstance(Object…obj):调用构造器
package com.jwt.reflection;

import java.lang.reflect.Constructor;

public class ReflecCreateInstance {
    public static void main(String[] args) throws Exception {
        //1. 先获取到User 类的Class 对象
        Class<?> userClass = Class.forName("com.jwt.reflection.User");
        //2. 通过public 的无参构造器创建实例
        Object user1 = userClass.newInstance();
        System.out.println(user1);
        //3. 通过public 的有参构造器创建实例
        //3.1 先得到对应构造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
        //3.2 创建实例,并传入实参
        Object user2 = constructor.newInstance("小简");
        System.out.println(user2);
        //4. 通过非public 的有参构造器创建实例
        //4.1 得到private 的构造器对象
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
        //4.2 创建实例
        //暴破【暴力破解】, 使用反射可以访问private 构造器/方法/属性
        constructor1.setAccessible(true);
        Object user3 = constructor1.newInstance(100, "张三丰");
        System.out.println(user3);
    }
}


class User {
    private int age = 10;
    private String name = "小明";
    public User() {//无参public
    }
    public User(String name) {//public 的有参构造器
        this.name = name;
    }
    private User(int age, String name) {//private 有参构造器
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

反射访问类中的成员

访问属性

  • 1.根据属性名获取Field对象
    • Field f = class对象.getDeclaredField(属性名);
  • 2.暴破
    • f.setAccessible(true); //f是Field
  • 3.访问
    • f.set(o,值); //o表示对象
    • f.get(o); //o表示对象
  • 4.注意:如果是静态属性,则set和get中的参数o,可以写成null
package com.jwt.reflection;

import java.lang.reflect.Field;
public class ReflecAccessProperty {
    public static void main(String[] args) throws Exception {
        //1. 得到Student 类对应的Class 对象
        Class<?> stuClass = Class.forName("com.jwt.reflection.Student");
        //2. 创建对象
        Object o = stuClass.newInstance();//o 的运行类型就是Student
        System.out.println(o.getClass());//Student
        System.out.println(o);
        //3. 使用反射得到age 属性对象
        Field age = stuClass.getField("age");
        System.out.println(age.get(o));//返回age 属性的值
        age.set(o, 88);//通过反射来操作属性
        System.out.println(o);
        System.out.println(age.get(o));
        //4. 使用反射操作name 属性
        Field name = stuClass.getDeclaredField("name");
        //对name 进行暴破, 可以操作private 属性
        name.setAccessible(true);
        name.set(o, "小明");
        System.out.println(name.get(o)); //获取属性值
        System.out.println(o);
        
        name.set(null, "小红");//因为name 是static属性,因此o 也可以用null
        System.out.println(name.get(null));//获取属性值, 要求name 是static
        System.out.println(o);
    }
}

class Student {//类
    public int age;
    private static String name;
    public Student() {//构造器
    }
    @Override
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }
}

访问方法

  • 1.根据方法名和参数列表获取Method方法对象
    • Method m = class对象.getDeclaredMethod(方法名,XX.class);
  • 2.获取对象: Object o = class对象.newlnstance();
  • 3.暴破: m.setAccessible(true);
  • 4.访问: Object returnValue = m.invoke(o,实参列表);
  • 5.注意:如果是静态方法,则invoke的参数o,可以写成null!
package com.jwt.reflection;

import java.lang.reflect.Method;

public class ReflecAccessMethod {
    public static void main(String[] args) throws Exception {
        //1. 得到Boss 类对应的Class 对象
        Class<?> bossCls = Class.forName("com.jwt.reflection.Boss");
        //2. 创建对象
        Object o = bossCls.newInstance();
        //3. 调用public 的hi 方法
        //3.1 得到hi 方法对象
        Method hi = bossCls.getMethod("hi", String.class);//OK
        //Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
        //3.2 调用
        hi.invoke(o, "小明");
        //4. 调用private static 方法
        //4.1 得到say 方法对象
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        //4.2 因为say 方法是private, 所以需要暴破,原理和前面讲的构造器和属性一样
        say.setAccessible(true);
        System.out.println(say.invoke(o, 100, "张三", '男'));
        //4.3 因为say 方法是static 的,还可以这样调用,可以传入null
        System.out.println(say.invoke(null, 200, "李四", '女'));
        //5. 在反射中,如果方法有返回值,统一返回Object , 但是他运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 300, "王五", '男');
        System.out.println("reVal 的运行类型=" + reVal.getClass());//String
        //在演示一个返回的案例
        Method m1 = bossCls.getDeclaredMethod("m1");
        Object reVal2 = m1.invoke(o);
        System.out.println("reVal2 的运行类型=" + reVal2.getClass());//Monster
    }
}

class Monster {}
class Boss {//类
    public int age;
    private static String name;

    public Boss() {//构造器
    }

    public Monster m1() {
        return new Monster();
    }

    private static String say(int n, String s, char c) {//静态方法
        return n + " " + s + " " + c;
    }

    public void hi(String s) {//普通public 方法
        System.out.println("hi " + s);
    }
}

本章练习

练习1

通过反射修改私有成员变量

  • 1.定义 PrivateTest 类, 有私有 name 属性,属性值为 hellokitty
  • 2.提供 getName 的公有方法
  • 3.利用 Class 类得到私有的 name 属性,修改私有的 name 属性值,并调用 getName() 的方法打印 name 属性值
package com.jwt.reflection;

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

public class Homework01 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
        Class<?> aClass = Class.forName("com.jwt.reflection.PrivateTest");
        Object o = aClass.newInstance();
        Field name =  aClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"小明");
        Method getName = aClass.getMethod("getName");
        Object returnValue = getName.invoke(o);
        System.out.println("returnValue = " + returnValue);
    }
}

class PrivateTest{
    private String name = "hellokitty";
    public String getName() {
        return name;
    }
}

练习2

利用反射和 File 完成以下功能

  • 1.利用 Class 类的 forName 方法得到 File 类的 class 对象
  • 2.在控制台打印 File 类的所有构造器
  • 3.通过 newInstance 的方法创建 File 对象, 并创建 /Users/jianjian/Downloads/mynew.txt 文件
  • 提示:创建文件的正常写法如下:
    • File file = new File(“路径”);
    • file.createNewFile();
package com.jwt.reflection;

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

public class Homework02 {
    public static void main(String[] args) throws Exception, {
        //得到 File 类的 class 对象
        Class<?> aClass = Class.forName("java.io.File");
          //打印 File 类的所有构造器
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor<?> i:declaredConstructors){
            System.out.println("File构造器 = " + i);
        }
        //指定构造器创建File对象
        Constructor<?> dc = aClass.getDeclaredConstructor(String.class);
        Object fileObj = dc.newInstance("/Users/jianjian/Downloads/mynew.txt");
        //得到createNewFile的方法对象
        Method createNewFile = aClass.getMethod("createNewFile");
        createNewFile.invoke(fileObj);
        System.out.println("创建成功");
    }
}

标签:Java,class,基础,System,public,println,out,Class,科普
From: https://blog.csdn.net/Rookie_CEO/article/details/141125206

相关文章

  • Rounding necessary错误解决Java的BigDecimal除法的
    出现Roundingnecessary错误原因是使用了BigDecimal的setScale方法导致。错误原因:setScale方法保留小数位数小于实际位数并且未指定roundingMode参数即报错。如下代码:BigDecimalrs=newBigDecimal("2057.9200");rs.setScale(2);上述代码实际数值是2057.9200是4位小......
  • 最新Java面试题及答案(500道)
    第一章-Java基础篇Object中有哪些方法   难度系数:⭐protectedObjectclone()--->创建并返回此对象的一个副本。booleanequals(Objectobj)--->指示某个其他对象是否与此对象“相等protectedvoidfinalize()--->当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃......
  • Java入门学习——Day04 运算符
            在Java编程中,运算符是基本的构建块,用于执行各种操作,如算术、比较和逻辑操作。了解运算符的使用对于编写正确的代码非常重要。目录一、算数运算符1.加法2.减法3.乘法4.除法二、赋值运算符1.赋值2.加赋值3.减赋值4.乘赋值5.除赋值6.取余赋值三、......
  • 【算家云】基础操作教程01 注册与登录
    为方便广大用户快速上手算家云,我们将提供算家云的基础操作教程,即便是零基础的小白也能轻松使用。现在就跟着一起来吧!一、进入官网在浏览器地址栏输入以下网址,进入算家云官网【https://www.suanjiayun.com/】点击【立即体验】或右上角【进入平台】,打开注册页面二、注册......
  • java中的命名规范(阿里巴巴)
    (一)命名风格1.命名不能以下划线开始,也不能以下划线结束。2.命名严禁使用拼音与英文混合的方式,更不允许使用中文。但是:alibaba/taobao hangzhou等国际通用的名称,可视同英文。3.类名使用大驼峰风格,必须遵从驼峰形式。即每个单词首字母大写。类名如果有复数含义,类名......
  • Linux常用基础命令
    1.1Linux系统的文件结构1/bin二进制文件,系统常规命令2/boot系统启动分区,系统启动时读取的文件3/dev设备文件4/etc大多数配置文件5/home普通用户的家目录6/lib32位函数库7/lib6464位库8/media......
  • 奥特曼花园私照“惊”到AI圈创始人,引出OpenAI代号“草莓”神秘项目进展大讨论,匿名基础
    今天,SamAltman在X上晒了一张自家花园的照片,结果却把AI界的创始人们“惊”到了。图片公司高层突发的巨大变动,似乎并没有太多影响到这位当家人,奥特曼在海外媒体秀出了一张花园花盆中生长的草莓的宜人景色,并用他典型的全小写文字风格配文“我喜欢花园里的夏天”。看起来,既在......
  • 为了给Javaer落地DDD,我们不得不写开源组件
    本文上回书接《这是DDD建模最难的部分(其实很简单)》,欢迎关注我的同名公众号。https://mp.weixin.qq.com/s/HZKMLF0_I10iczzp2mAR-w 故事背景2013年中,我们的Java后端团队为了落地DDD,全面引入了dotnet技术栈,具体过程和成果,可以看我的B站频道《Java8到.NET8,团队升级报告-第......
  • JAVA自学练习网站——包会的(大三学生倾情推荐)
    一、自述:入门时我踩过的那些坑1.比起给我这些本科生上课,老师更关心自己的科研项目和手里的硕士博士,讲课还不如高中老师,跟着只会念PPT的老师学,越学越头大。2.只完成课后老师布置的一两道习题,等真正考试自己操作了根本不会。3.大学教学任务多的几节课就是一章,课后不自己学习很......
  • 【Redis】掌握Java中的Redis魔法:Jedis与Spring Data Redis(实战指南)
    文章目录掌握Java中的Redis魔法:Jedis与SpringDataRedis实战文章简介为什么使用Redis为什么选择Jedis和SpringDataRedis一、引言1.1Redis简介1.1.1Redis的特点和优势1.1.2Redis的应用场景1.2Java与Redis的结合1.2.1为什么选择Java1.2.2Java开发中Redis的重要......