java 反射简介

已于 2022-03-16 23:13:17 修改
阅读量576 收藏
点赞数
分类专栏： JAVA basis 文章标签： java
于 2022-03-16 23:11:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yx_smile/article/details/123533729
版权

反射

反射

链接:www.kuangstudy.com
在这里插入图片描述
在这里插入图片描述

1.2 java 反射的优缺点

优点: 可以实现动态创建对象和编译,体现出很大的灵活性

缺点: 对性能有影响,使用反射基本上是一种结实操作,我们可以告诉JVM,我们希望做什么并且他满足我们的要求,这类操作总是鳗鱼直接执行相同的操作

2.反射的主要API

java.lang.class : 代表一个类
java.lang.reflect.Method: 代表类的方法
java.lang.reflect.Field : 代表类的成员变量
java.lang.reflect.Constructor : 代表类的构造器

2.1 获得反射对象

package com.yx.fanshe;

//什么叫反射
public class TestFanshe{
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class c1 = Class.forName("com.yx.fanshe.User");
        System.out.println(c1);
        Class c2 = Class.forName("com.yx.fanshe.User");
        Class c3 = Class.forName("com.yx.fanshe.User");
        Class c4 = Class.forName("com.yx.fanshe.User");
        //一个类在内存中  只有一个class对象
        //一个类被加载后,整个类都会封装在class对象中
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());
    }

 }

//实体类
class User{
    private String name;
    private int id;
    private int age;

    public User() {
    }

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

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

在这里插入图片描述

2.2 得到class的几种方式

在这里插入图片描述

package com.yx.fanshe;
//测试class类的创建方式
public class HuoQuFangShi {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是:"+ person.name);

        //方式一: 通过对象获得
        Class c1 = person.getClass();
        //方式二: forname获得
        Class c2 = Class.forName("com.yx.fanshe.Student");
        System.out.println(c2);

        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        //方式三: 通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
        //获得父类的类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }

}
class Person{
    public String name;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Student extends Person{
    public Student() {
        this.name="学生";
    }
}
class Teacher extends Person{
    public Teacher() {
        this.name="老师";
    }
}

2.3 所有类型的class对象

在这里插入图片描述

package com.yx.fanshe;

import java.lang.annotation.ElementType;

//所有类型的class
public class AllClasss {
    public static void main(String[] args) {
        Class c1 = Object.class;    //类
        Class c2 = Comparable.class;   //接口
        Class c3 = String[].class;     //一维数组
        Class c4 = int[][].class;      //二维数组
        Class c5 = Override.class;      //注解
        Class c6 = ElementType.class;   //枚举
        Class c7 = Integer.class;       //基本数据类型
        Class c8 = void.class;          //void
        Class c9 = Class.class;         //Class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);
    }
}

2.4 什么时候会发生类初始化

在这里插入图片描述

2.6 类加载器在这里插入图片描述

在这里插入图片描述

package com.yx.fanshe;

public class TestClassLoader {
    public static void main(String[] args) throws ClassNotFoundException {

        //获取系统的类加载器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader);

        //获取系统类加载器的父类加载器  -->  扩展类加载器
        ClassLoader parent = classLoader.getParent();
        System.out.println(parent);

        //获得扩展类加载器的父类加载器   -->根加载器()
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //获取当前类是哪个加载器加载的
        ClassLoader what = Class.forName("com.yx.fanshe.TestClassLoader").getClassLoader();
        System.out.println(what);
        System.out.println("=================================================================================");
        //测试jdl内置的类是谁加载的
        ClassLoader loader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(loader);

        //如何获得系统类加载器可以加载的路径
        String property = System.getProperty("java.class.path");
        System.out.println(property);

        //双亲委派机制
        //想自己写 java.lang.string (不生效)--->  先看用户类加载器  --->  扩展类加载器   --->  根加载器   顺着包往上找
    }
}

2.7 获得类运行时的结构

package com.yx.fanshe;

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

public class YunXingJieGou {
    public static void main(String[] args) throws Exception {
        Class c1 = Class.forName("com.yx.fanshe.User");
        //通过反射
        /*User user = new User();
        c1 = user.getClass();*/
        //获得类的名字
        System.out.println(c1.getName());          //获得包名+类名
        System.out.println(c1.getSimpleName());     //获得类名
        System.out.println("=--=-=-=-=----------------======================-=-=-----------=-=-=-");
        //获得类的属性
       /* 只能找到 public 的属性
       Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }*/
        //可以找到全部的属性
        Field[] fields = c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        //通过指定的属性获得
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法
        System.out.println("----------------获得类的方法------------------------");
        获得本类和父类的所有方法
        Method[] method = c1.getMethods();
        for (Method method1 : method) {
            System.out.println("正常的: "+method1);
        }
        //获得本类的所有方法
        Method[] methods = c1.getDeclaredMethods();
        for (Method methods1 : method) {
            System.out.println("getDeclaredMethods  : "+methods1);
        }
        //获取指定的方法
        Method getName = c1.getMethod("getName");
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);
        System.out.println("======================获取指定构造器======================");
        //获取指定构造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }

        //通过参数获取指定构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class,int.class);
        System.out.println(declaredConstructor);
    }
}

2.8 动态创建对象执行方法

在这里插入图片描述

package com.yx.fanshe;

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

public class DongTaiChuangJian {
    public static void main(String[] args) throws Exception {
        //获得class对象
        Class c1 = Class.forName("com.yx.fanshe.User");
       /* //构造一个对象
        User user = (User) c1.newInstance();   //本质上是调用了无参构造器
        System.out.println(user);*/
       /* //通过构造器创建对象
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user2 = (User) declaredConstructor.newInstance("yx", 1, 21);
        System.out.println(user2);*/

        /*//通过反射构造方法
        User user3 = (User) c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user3,"yx");
        System.out.println(user3.getName());*/

        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //不能直接操作私有属性,我们需要关闭程序的安全检测,属性或者方法的setAccessible(true);
        name.setAccessible(true);
        name.set(user4,"yx");
        System.out.println(user4.getName());
    }
}

2.9 性能对比分析

package com.yx.fanshe;

import java.lang.reflect.Method;

//分析性能测试
public class TestXingNeng {
    //普通方法
    public static void test1(){
        User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方法执行10亿次:   "+(endTime-startTime)+" ms");
    }

    //发射方法调用
    public static void test2() throws Exception {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName");

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方法执行10亿次:   "+(endTime-startTime)+" ms");
    }

    //反射方式调用   关闭检测
    public static void test3() throws Exception {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName");
        getName.setAccessible(true);

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);

        }
        long endTime = System.currentTimeMillis();
        System.out.println("关闭后,反射方法执行10亿次:   "+(endTime-startTime)+" ms");
    }

    public static void main(String[] args) throws Exception {
        test1();
        test2();
        test3();
    }
}

2.10 获取泛型信息

在这里插入图片描述

勇往无前的梓荣
关注
专栏目录
Java反射简介
WillScorpio
01-17 519
一，简介 反射可以帮助我们在运行程序时候加载、使用编译期间完全未知的class，简单来说就是Java可以加载一个运行时候才得知名称的class，获得其完整的构造，并生成实例化对象，对其成员变量赋值，调用其方法等等。 在具体的研发中，通过反射获取类的实例，大大提高系统的灵活性和扩展性，同时由于反射的性能较低，而且它极大的破坏了类的封装性(通过反射获取类的私有方法和属性)，在大部分场景下并不适合使用反...
Java反射详细介绍
weixin_33716557的博客
07-31 194
反射 目录介绍 1.反射概述 1.1 反射概述 1.2 获取class文件对象的三种方式 1.3 反射常用的方法介绍 1.4 反射的定义 1.5 反射的组成 1.6 反射的作用有哪些 2.反射的相关使用 2.1.1 通过反射获取无参构造方法并使用 2.1.2 通过反射获取带参构造方法并使用 2.1.3 通过反射获取私有构造方法并使用 2.1.4 通过反射获取成员变量并使用 2.1.5 通...
Java 反射详解
IT可乐
03-07 218
&#13; 　　反射反射，程序员的快乐！&#13; 一、什么是反射？　　通过百度百科我们可以知道，Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态（或准动态，为啥要说是准动态，因为一般而言的动态语言定义是程序运行时，允许改变程序结构或变量类型，这种语...
Java反射机制
07-24 739
反射，reflection，听其名就像照镜子一样，可以看见自己也可以看见别人的每一部分。在java语言中这是一个很重要的特性。下面是来自sun公司官网关于反射的介绍：    Reflection is a feature in the Java programming language. It allows an executing Java program to examine
java-reflection:Java 反射简介
07-08
Java反射是Java编程语言中的一个强大工具，它允许运行时的程序访问并操作类、接口、字段和方法等对象，即使这些对象在编译时并未被明确地引用。这一特性使得Java具有高度的动态性，可以实现元编程，即在程序运行时...
java 反射
12-22
这种动态获取信息以及动态调用对象方法的功能成为java反射机制。 2. java 文件和 .class 文件的关系 java 文件 java文件中包含代码的所有内容，类，接口，成员变量，成员方法.... .class 字节码文件 .class 是由 ...
Java反射技术详解及实例解析
08-18
Java反射技术是Java编程语言中的一个强大特性，它允许程序在运行时检查并操作类、接口、对象等的内部信息，包括但不限于类名、方法、字段等。这种能力使得Java程序具有高度的灵活性和动态性，是许多高级框架和库的...
Java反射在实际工作中的应用笔记
08-28
Java反射在实际工作中的应用笔记 Java反射是Java语言中一个非常重要的特性，它可以在实际工作中发挥着非常重要的作用。通过Java反射，我们可以在运行时动态地调用类的成员变量和方法，从而实现了更加灵活和灵活的...
Java反射案例
01-09
Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中，反射机制的核心类集中在java.lang.reflect包下，包括Class、Constructor、Method和Field...
原创 Java反射介绍
redarmychen的专栏
02-27 1961
          反射是Java程序开发语言的特征之一。它允许动态地发现和绑定类、方法、字段，以及所有其他的由语言所产生的元素,在闲来之余,把上周上课的知识点列举如下,希望同学对Java反射有所进一步的了解.     反射用到的API如下：     Java反射所需要的类并不多，主要有java.lang.Class类和java.lang.reflect包中的Field、Const
java反射简介
Yenjeanhung的博客
04-23 177
目录 反射 一、反射的概述 二、查看Class类在java中的api详解 三、反射的使用（这里使用Student类做演示） 1、获取Class对象的三种方式 2、通过反射获取构造方法并使用： 3、获取成员变量并调用 4、获取成员方法并调用 5、反射main方法 6、反射方法的其它使用之---通过反射运行配置文件内容 7、反射方法的其它使用之---通过反射越过泛型检查 反射 ...
java反射介绍
peace唠叨
09-17 1421
反射是java中的非常重要的一项机制，也称做reflection。它让java在运行中对自身进行检查，并能直接操作程序的内部属性或方法。 ​
Java反射介绍
最新发布
派大星的博客
09-21 1483
总结介绍java反射基本知识，希望对java安全初学者有所帮助。
JVM如何处理方法调用
weixin_34261415的博客
08-14 166
方法调用不是方法执行，方法调用是让jvm确定调用哪个方法，所以，程序运行时的它是最普遍、最频繁的操作。jvm需要在类加载期间甚至运行期间才能确定方法的直接引用。 解析 所有方法在Class文件都是一个常量池中的符号引用，类加载的解析阶段会将其转换成直接引用，这种解析的前提是：要保证这个方法在运行期是不可变的。这类方法的调用称为解析。 jvm提供了5条方法调用字节码指令： [ ] invoke...
深入理解Java反射机制
"Java反射机制是Java编程中的重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。通过Java反射，开发者可以在不知道具体类名的情况下，对类进行实例化，调用方法，访问和修改属性，实现更加灵活的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值