java反射机制

最新推荐文章于 2022-11-24 11:19:29 发布
最新推荐文章于 2022-11-24 11:19:29 发布
阅读量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 1500
在使用反射的时候,常用到的几个方法老是傻傻的分不清楚是干吗的,功能差不多的啊,比如:Class.getFields(), Class.getField(String), Class.getDeclaredFields(), Class.getDeclaredField(String)和Class.getMethods(), Class.getMethod(String, Class[]), Cla...
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
Java进阶——反射机制
LiLi的博客
12-05 469
反射机制（比较简单，因为只要会查帮助文档，就可以了） 反射机制有什么用？ 通过java语言中的反射机制可以操作字节码文件。 优点类似于黑客。（可以读和修改字节码文件） 通过反射机制可以操作代码片段。（class文件） 反射机制的相关类在哪个包下？ java.lang.reflect.*; 反射机制相关的重要的类有哪些？ java.lang.Class：代表整个字节码，代表一个类型，代表整个类。 java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。
java反射的field.get(null)
拼老命的程序猿
04-10 6986
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 反射机制
08-31
本文将深入探讨Java反射机制，并结合给出的代码示例进行解析。 首先，我们来看如何通过反射获取类的基本信息。在代码中，`Class.forName("reflection.User")` 是用来加载名为 `User` 的类，返回一个 `Class` 对象。...
JAVA反射机制实例教程
09-04
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。通过反射，开发者可以访问和修改私有成员，调用私有方法，创建对象，以及对类、接口、字段和方法进行操作，极大地...
java反射机制.zip
11-24
java反射机制java反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制...
Java反射机制用法总结
08-25
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的...这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。下面我们来一起学习一下吧
java反射机制介绍及使用
最新发布
10-09
Java反射机制是Java语言提供的一种强大的工具，它允许程序在运行时动态地访问和修改类的行为。这种机制的核心在于能够获取类的元数据信息，并基于这些信息实例化对象、调用方法、访问和修改字段的值，从而实现高度的...
Java反射机制
07-10
java反射机制的实战练习
java反射机制示例
09-04
Java反射机制是Java语言提供的一种强大功能，它允许程序在运行时动态地获取类的信息（如类名、属性、方法等）并进行操作。在上述示例中，我们看到如何利用反射来创建对象、调用方法，这展示了反射机制的核心应用。 ...
Java反射机制详解
09-03
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并调用其方法。反射机制提供了对Java类和对象的元数据的访问，从而增加了代码的灵活性和动态性。 首先，要理解Java反射的预备...
Java的反射机制
qq_41193133的博客
03-13 3693
什么是反射？ Java的反射是指在程序运行期间可以
java使用反射调用对象get方法
L_Lawrence的博客
11-24 2548
【代码】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反射机制原理详解
06-06
### 回答1： Java反射机制是指在运行时动态地获取一个类的信息，并可以操作类的属性、方法和构造器等。Java反射机制可以使程序员在运行时动态地调用类的方法和属性，扩展类的功能，并可以实现注解、工厂模式以及框架开发等。 Java反射机制的原理如下：首先，Java编译器将Java源代码编译为字节码文件，字节码文件中包含着类的信息，这些信息包括类的名称、方法、属性和构造器等等。接着，Java虚拟机将字节码文件加载到内存中，然后通过类加载器将类加载到内存中形成一个类对象，这个类对象可以操作字节码文件中的信息。 使用Java反射机制的过程如下：首先获取类对象，通过类对象来获取类的构造器、属性、方法等信息，然后调用构造器来创建对象，通过属性获取和设置类的成员属性，通过方法调用类的方法等。 Java反射机制的优点是可以在运行时动态地得到类的信息，使得程序员在程序运行时能够对类进行更加灵活的操作，并可以使得程序更加通用化，同时也存在着一定的性能问题，因为Java反射机制需要Java虚拟机进行一定的额外处理，所以在程序运行时需要进行额外的时间和资源消耗。 总之，Java反射机制是Java语言的一项重要特性，在Java开发中广泛应用，在代码编写、框架开发以及API开发中具有重要作用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值