java反射机制

最新推荐文章于 2023-12-26 00:00:00 发布
最新推荐文章于 2023-12-26 00:00:00 发布
阅读量445 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51809035/article/details/124093735
版权

目录

资料视频：韩顺平-反射专题
在这里插入图片描述

OCP：开闭原则（设计模式）
对扩展开放，对修改是关闭的
对象类：

public class Cat {
    private String name="asd";
    public int age=10;

    public Cat() {
    }

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

    public void hi(){
        System.out.println("hi~~~");
    }
    public void cry(){
        System.out.println("cry cry~~~");
    }
}

properties：

classfullpath=com.company.Cat
method=hi

public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {

        //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();
        System.out.println("classfullpath = "+classfullpath);
        System.out.println("method = "+methodName);


        //1.加载类，返回Class类型的对象cls
        Class cls = Class.forName(classfullpath);

        //2. 通过cls得到需要加载的类com.company.Cat 的对象实例
        Object o = cls.newInstance();
        //3. 通过cls得到想要加载的类Cat的methodName“hi”的方法对象
        //反射中方法也被视为对象
        Method method1 = cls.getMethod(methodName);
        //4. 通过method1调用方法：即通过方法对象来实现调用方法
        method1.invoke(o);//传统方法：对象的实例.方法(),反射机制：方法.invoke(对象的实例)
        
        //通过cls得到你加载的类com.company.Cat
//        System.out.println(o.getClass());
    }
}

输出：

classfullpath = com.company.Cat
method = hi
hi~~~

== cls是加载类，o是对象实例，method1是方法对象==
改变properties

classfullpath=com.company.Cat
method=cry

输出也会改变：

classfullpath = com.company.Cat
method = cry
cry cry~~~

但是我们并没有改变代码，只是改变了properties

在这里插入图片描述

注意一点：Class类对象是一个对象，存在于堆中

XXX a=new XXX()
堆：存放对象实例new XXX()， 栈：存放地址信息 a，方法区（静态区）：程序中唯一的元素，如class、static
Cat类的字节码二进制数据在方法区
类对象不是类而是对象，所以不在方法区，而是在堆中

  //java.lang.reflect.Field
        //反射获取类的属性值
        //getField不能获取私有属性
        Field age = cls.getField("age");
        System.out.println(age.get(o));//传统方法：对象.成员变量(),反射机制：成员变量.get(对象的实例)

        //java.lang.reflect.Field
        Constructor constructor = cls.getConstructor();
        System.out.println(constructor);


        Constructor constructor2 = cls.getConstructor(String.class);
        System.out.println(constructor2);

反射调优：

public class Reflection02 {
    public static void main(String[] args) throws Exception {
        Reflection02 reflection02 = new Reflection02();
        reflection02.m1();
        reflection02.m2();
        reflection02.m3();
    }
    public void m1(){
        Cat cat = new Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 90000000; i++) {
            cat.hi();
        }
        long end = System.currentTimeMillis();
        System.out.println("传统方法时间 = "+(end-start));

    }
    public void m2() throws Exception {
        Class cls = Class.forName("com.company.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 90000000; i++) {
            hi.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("反射方法时间 = "+(end-start));

    }

    public void m3() throws Exception {
        Class cls = Class.forName("com.company.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        //在反射调用方法时，取消访问检查
        hi.setAccessible(true);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 90000000; i++) {
            hi.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("反射调优时间 = "+(end-start));

    }
}

传统方法时间 = 2
反射方法时间 = 111
反射调优时间 = 90

Class也是类，继承了Object类

Class类不是new出来的，是系统创建出来的

对于某个类的Class类对象，在内存中只有一份，因为类只加载一次

		//3.对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
	  	Class aClass = Class.forName("com.company.Cat");
        Class aClass2 = Class.forName("com.company.Cat");
        System.out.println(aClass2==aClass);//true

在这里插入图片描述

public class Class02 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        String classAllPath="com.company.Cat";

        Class aClass = Class.forName(classAllPath);

        System.out.println(aClass);//class com.company.Cat，是哪个类的Class对象
        System.out.println(aClass.getClass());//输出运行类型  java.lang.Class

        System.out.println("=====================");
        
        //得到包名  com.company
        System.out.println(aClass.getPackage().getName());
        //得到全类名  com.company.Cat
        System.out.println(aClass.getName());
        //通过aClass创建对象
        Cat cat = (Cat)aClass.newInstance();
        System.out.println(cat);

        System.out.println("=====================");

        //通过反射获取属性 共有属性
        Field age = aClass.getField("age");
        System.out.println(age.get(cat));//10
        //通过反射给属性赋值
        age.set(cat,18);
        System.out.println(age.get(cat));//18
        //得到所有属性
        Field[] fields = aClass.getFields();
        for (Field f:fields){
            System.out.println(f.getName());
        }

    }
}


class com.company.Cat
class java.lang.Class
=====================
com.company
com.company.Cat
com.company.Cat@1b6d3586
=====================
10
18
age

在这里插入图片描述
在这里插入图片描述

四种方式获取Class对象

得到的Class对象都是同一个

public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {
        String classAllPath="com.company.Cat";

        //四种方式获取Class对象
        Class aClass = Class.forName(classAllPath);
        System.out.println(aClass);

        Class aClass2= Cat.class;
        System.out.println(aClass2);

        Cat cat = new Cat();
        Class aClass3 = cat.getClass();

        System.out.println(aClass==aClass2);//true
        System.out.println(aClass==aClass3);//true


        //通过类加载器获得类的Class对象
        ClassLoader classLoader = cat.getClass().getClassLoader();
        Class aClass4 = classLoader.loadClass(classAllPath);
        System.out.println(aClass==aClass4);//true
    }
}

几种基本类型的Class对象

        Class<Integer> integerClass = int.class;
        Class<Integer> integerClass1 = Integer.class;
        Class<String> stringClass = String.class;
        Class<Boolean> booleanClass = boolean.class;


        Class<Integer> type = Integer.TYPE;
        Class<Character> type1 = Character.TYPE;
        System.out.println(integerClass==type);//true

在这里插入图片描述

动态和静态加载

在这里插入图片描述
在这里插入图片描述
我们发现有一个new Dog()，它会直接编译报错，这是静态加载
case 2 中，只有“Person”字符串，并没有写Person，我们编译的是Class.forName(),并没有加载Person，
只有在我们key=2的时候，我们去找Person类，然后加载它，运行的时候才会用它，即使没有Person类，只要不运行它，就不会报错

类加载流程图

在这里插入图片描述
在这里插入图片描述

  • 加载：ClassLoader（）
  • 验证：验证字节码和一些安全方面的东西
  • 准备：静态变量默认初始化
  • 解析：符号引用转为直接引用
  • 初始化：程序员写的代码，对静态变量进行初始化赋值

连接阶段-准备

  1. JVM会在该阶段对静态变量，分配内存并默认初始化
    在这里插入图片描述

class B{
    static {
        System.out.println("静态代码块已执行");
        num=100;
    }
    static  int num=300;
    public B(){
        System.out.println("构造方法已执行");
    }
}

当我们new B()的时候

  1. 加载B类，并生成B的class对象
  2. 链接 num=0
  3. 初始化阶段 -依次自动收集类中的所有静态变量的赋值动作和静态代码块，并合并
    clinit(){
    System.out.println(“静态代码块已执行”);
    //合并num为100
    num=300;
    num=100;
    }
  4. 执行构造器
    在这里插入图片描述
    加载类的时候会加锁
    保证每个类的Class类对象只有一个

获取类结构信息

public class ReflectionUtils {
    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        Class personCls = Class.forName("com.company.reflection.Person");
        System.out.println(personCls.getName());
        System.out.println(personCls.getSimpleName());

        Field[] fields = personCls.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }
        System.out.println("===========================");

        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField.getName());
        }
        System.out.println("==========获取本类所有方法===========");
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
            System.out.println(method.getName());
        }
        System.out.println("==========获取本类构造方法(公有的)===========");
        Constructor[] constructors = personCls.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName());
            
        }
        System.out.println("==========获取本类所有构造方法(包括私有)===========");
        Constructor[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor.getName());
        }
        System.out.println("=============================");
        System.out.println(personCls.getPackage());

        System.out.println(personCls.getSuperclass());

        Class[] interfaces = personCls.getInterfaces();
        for (Class anInterface : interfaces) {
            System.out.println(anInterface);
        }
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

    }
}

class A{
    public String hobby;
    public void AAA(){

    }
}

interface  IA{

}
interface  IB{

}

@Deprecated
class Person extends A implements IA,IB{
    public String name;
    protected int age;
    String job;
    private double sal;

    public Person() {
    }

    private Person(String name) {
        this.name = name;
    }

    public  void m1(){

    }
    protected  void m2(){

    }
    void m3(){

    }
    private void m4(){

    }
}

com.company.reflection.Person
Person
name
hobby
===========================
name
age
job
sal
==========获取本类所有方法===========
m1
AAA
wait
wait
wait
equals
toString
hashCode
getClass
notify
notifyAll
==========获取本类构造方法===========
com.company.reflection.Person
==========获取本类所有构造方法(包括私有)===========
com.company.reflection.Person
com.company.reflection.Person
=============================
package com.company.reflection
class com.company.reflection.A
interface com.company.reflection.IA
interface com.company.reflection.IB
@java.lang.Deprecated()

Field和Method都有getModifiers（）方法
在这里插入图片描述

反射可以访问私有属性，构造器

public class ReflecCreateInstance {
    public static void main(String[] args) throws Exception {
        Class userClass = Class.forName("com.company.reflection.User");
        //通过public的无参构造创建实例
        Object o = userClass.newInstance();
        System.out.println(o);

        //通过public有参构造器创建实例
        //先得到构造器
        Constructor constructor = userClass.getConstructor(String.class);
        //创建实例，并传入实参
        User o1 =(User) constructor.newInstance("你好");
        System.out.println(o1);


        //通过非public的有参构造器创建实例
        //得到private构造器
        Constructor declaredConstructor = userClass.getDeclaredConstructor(int.class, String.class);
        declaredConstructor.setAccessible(true);//暴力破解
        //创建对象
        Object hello = declaredConstructor.newInstance(11, "hello");
        System.out.println(hello);

    }
}

class User{
    private int age;
    private String name;

    public User() {
    }

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

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

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

访问静态属性和方法

public class ReflecAccessProperty {
    public static void main(String[] args) throws Exception {
        Class<?> stuClass = Class.forName("com.company.reflection.Student");

        Object o = stuClass.newInstance();
        System.out.println(o);

        //反射获取age属性
        Field age = stuClass.getField("age");
        //反射操作属性
        age.set(o,11);
        System.out.println(o);
        System.out.println(age.get(o));

        //使用反射操作name
        Field name = stuClass.getDeclaredField("name");
        name.setAccessible(true);
//        name.set(o,"hhh");
        //只有静态属性才可以写null
        name.set(null,"hhh");
        System.out.println(name.get(null));
    }
}
class Student{
    public int age;
    private static String name;

    public Student() {
    }

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

爆破

public class ReflecAccessMethod {
    public static void main(String[] args) throws Exception {
        Class<?> bossClass = Class.forName("com.company.reflection.Boss");

        Object o = bossClass.newInstance();

        //调用普通方法  只能获取public
        Method hi = bossClass.getMethod("hi",String.class);
        //可以获取private
        hi = bossClass.getDeclaredMethod("hi",String.class);
        Object jiaoyu = hi.invoke(o, "jiaoyu");
        System.out.println(jiaoyu);//null

        Method say = bossClass.getDeclaredMethod("say", int.class, String.class, char.class);
        //因为say是私有的，需要爆破
        say.setAccessible(true);
        System.out.println(say.invoke(o,666,"hhh",'q'));

        //返回值
        System.out.println(say.getReturnType());
    }
}
class Boss{
    public int age;
    private static String name;

    public Boss() {
    }

    private static String say(int n, String s, char c){
        return n+" "+s+" "+c;
    }
    public void hi(String s){
        System.out.println("hi "+s);
    }

}
猴子会跳舞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 反射 field get方法_JAVA学习之反射getDeclaredField()方法与getField()方法的区别
weixin_35343148的博客
02-13 1499
在使用反射的时候,常用到的几个方法老是傻傻的分不清楚是干吗的,功能差不多的啊,比如:Class.getFields(), Class.getField(String), Class.getDeclaredFields(), Class.getDeclaredField(String)和Class.getMethods(), Class.getMethod(String, Class[]), Cla...
详解JAVA 反射机制
08-19
主要介绍了JAVA 反射机制的相关知识，文中讲解的非常细致，代码帮助大家更好的理解学习，感兴趣的朋友可以了解下
Java进阶——反射机制
LiLi的博客
12-05 469
反射机制（比较简单，因为只要会查帮助文档，就可以了） 反射机制有什么用？ 通过java语言中的反射机制可以操作字节码文件。 优点类似于黑客。（可以读和修改字节码文件） 通过反射机制可以操作代码片段。（class文件） 反射机制的相关类在哪个包下？ java.lang.reflect.*; 反射机制相关的重要的类有哪些？ java.lang.Class：代表整个字节码，代表一个类型，代表整个类。 java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。
java反射的field.get(null)
拼老命的程序猿
04-10 6984
http://huangyunbin.iteye.com/blog/1942365 在java的反射中,通过字段获取对象,是通过  Java代码   public Object get(Object obj)   字段不是静态字段的话,要传入反射类的对象.如果传null是会报  java.lang.NullPointerException  但是
JAVA反射系列之Field,java.lang.reflect.Field使用获取方法。
秋夫人
02-23 1917
首先必须明一点 Field类主要是用来辅助获取和操作类的属性的！ 1.怎么通过反射获取类的属性      先来看JDK提供的方法有如下几种：          a)Class.getDeclaredField(String name);      返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。      b)Class.g
java反射field_java反射(Field的应用)
weixin_30015371的博客
02-20 166
//$Id: DirectPropertyAccessor.java 11405 2007-04-15 12:50:34Z max.andersen@jboss.com $packageorg.hibernate.property;importjava.lang.reflect.Field;importjava.lang.reflect.Method;importjava.util.Map;imp...
java 反射机制
05-09
java 反射机制深入理解，java 反射机制深入理解，java 反射机制深入理解，
java反射机制.zip
11-24
java反射机制java反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制...
JAVA反射机制实例教程
09-04
主要介绍了JAVA反射机制,包括了Java反射机制的各种应用技巧,非常具有实用价值,需要的朋友可以参考下
Java的反射机制
qq_41193133的博客
03-13 3692
什么是反射？ Java的反射是指在程序运行期间可以
java使用反射调用对象get方法
L_Lawrence的博客
11-24 2547
【代码】java使用反射调用对象get方法。
java反射-Field
poker face
09-02 73
package reflect; import java.lang.reflect.Field; public class ReflectionTest { @SuppressWarnings("unchecked") public static void main(String[] args) throws Exception { Point poin...
Java反射之getFields()、getDeclaredFields()方法
fly_Xiaoma的博客
12-15 3217
在Java开发中，有两种获取字段的方式：getFields()和getDeclaredFields()。 两者区别： getFields():获取某个类的所有的公共（public）的字段，包括父类中的字段 getDeclaredFields()：获取某个类的所有声明的字段，即包括public 、private和protected，但是不包括父类中的声明字段 类似的方法： 获取某个类的方法...
浅谈Java反射中的getFields()方法和getDeclaredFields ()方法
最新发布
码农研究僧的博客
12-26 4475
反射是Java中一种强大的机制，允许在运行时获取、检查和操作类、方法、字段等信息，而不需要在编译时知道这些信息。其中字段（Field）在Java中是类中用于存储数据的成员变量。在反射中，可以通过Field类获取和操作类的字段。 getFields()该方法用于获取某个类及其父类中所有的公有字段。公有字段是指用public修饰的字段。这个方法对于需要获取类的公有属性时很有用。 getDeclaredFields()该方法用于获取某个类中声明的所有字段，包括公有、私有、受保护的字段，但不包括继承的字段。
JAVA反射
fox_bert的博客
05-16 118
一、Java反射的概念 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象. 一个类有：...
JAVA反射中的getFields()方法和getDeclaredFields ()方法的区别
hello_xing的博客
04-20 326
JAVA反射中的getFields()方法和getDeclaredFields ()方法的区别 关于获取类的字段有两种方式：getFields()和getDeclaredFields()。我们先来看看这两者的区别吧： getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段。 getDeclaredFields()：获得某个类的所有声明的字段，即包括public...
Java Reflection(四):变量
feel369的博客
11-26 504
内容索引 获取Field对象 变量名称 变量类型 获取或设置（get/set）变量值 使用Java反射机制你可以运行期检查一个类的变量信息(成员变量)或者获取或者设置变量的值。通过使用java.lang.reflect.Field类就可以实现上述功能。在本节会带你深入了解Field对象的信息。 获取Field对象 可以通过Class对象获取Field对象，如下例： Class aClass = ...//获取Class对象 Field[] methods = aClass.getFiel
JavaSE进阶 | 反射机制（反射Method、Constructor、Field）
m0_61933976的博客
09-05 1794
JavaSE | 反射机制（反射Method、Constructor、Field）
java反射机制原理详解
06-06
Java反射机制是指在运行时动态地获取一个类的信息，并可以操作类的属性、方法和构造器等。Java反射机制可以使程序员在运行时动态地调用类的方法和属性，扩展类的功能，并可以实现注解、工厂模式以及框架开发等。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值