JavaWeb开发（三）3.5——Java的反射机制

于 2023-03-05 17:31:15 发布
阅读量475 收藏
点赞数
分类专栏： JavaWeb开发 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36216193/article/details/129331041
版权

一、反射机制的概念

  • 指在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法，对于任意一个对象，都能调用它的任意一个方法。这种动态获取信息，及动态调用对象方法的功能叫java语言的反射机制。

  • Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。

  • Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

二、反射的原理

（1）正常类的加载过程：

  • 当执行new 方法，会触发JVM加载该对象的 .class 文件；
  • JVM 从本地磁盘找到 .class 文件并加载到JVM内存中；
  • .class 文件加载入内存后，JVM 会自动创建一个class 对象。（一个类只会产生一个class 对象）

（2）Java反射过程：
得到JVM内存中的class 对象，反向获取对象的各种信息。

在这里插入图片描述

三、反射的优缺点

1、优点

在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。

2、缺点

（1）反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；
（2）反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。

四、反射的用途

  1. 可以进行反编译：.class–>.java
  2. 通过反射机制访问java对象的属性，方法，构造方法等。
  3. 我们在使用IDE，如Ecplise时，当输入一个对象或者类，并想调用他的属性和方法是，一按点号，编译器就会自动列出他的属性或者方法，这里就是用到反射。
  4. 反射最重要的用途就是开发各种通用框架。比如很多框架（Spring）都是配置化的（比如通过XML文件配置Bean），为了保证框架的通用性，他们可能需要根据配置文件加载不同的类或者对象，调用不同的方法，这个时候就必须使用到反射了，运行时动态加载需要的加载的对象。
  5. 加载数据库驱动的，用到的也是反射。
    eg：
Class.forName("com.mysql.jdbc.Driver"); // 动态加载mysql驱动

五、反射的常见使用

1、获得Class：主要有三种方法

  • （1）getClass()。
  • （2）任何数据类型（包括基本的数据类型）都有一个“静态”的class属性。
  • （3）通过class类的静态方法：forName(String className)（最常用）。

注：三种方式中，常用第三种方式，
第一种对象都有了还要反射干什么，
第二种需要导入类包，依赖太强，不导包就抛编译错误。
一般都使用第三种，一个字符串可以传入也可以写在配置文件中等多种方法。

eg:
Student 类：

package com.qizekj.clazz;

/**
 * @author chenqun
 * @date 2023/3/4 11:13
 */
public class Student {
    private String name;
    private int age;
    private String stuNo;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

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

获得Class的三种示例：

public class GetClassTest {
    public static void main(String[] args) {
        //第一种方式获取Class对象
        Student stu1 = new Student();//new 产生一个Student对象，一个Class对象。
        Class stuClass = stu1.getClass();//获取Class对象
        System.out.println(stuClass.getName());

        //第二种方式获取Class对象
        Class stuClass2 = Student.class;
        System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
        
        //第三种方式获取Class对象
        try {
            Class stuClass3 = Class.forName("com.qizekj.clazz.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
            System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

注意，在运行期间，一个类，只有一个Class对象产生，所以打印结果都是true；

2、判断是否为某个类的示例

一般的，我们使用 instanceof 关键字来判断是否为某个类的实例。同时我们也可以借助反射中Class对象的 isInstance() 方法来判断是否为某个类的实例，他是一个native方法。

public native boolean isInstance(Object obj);

3、通过反射来生成对象的两种方法

（1）使用Class对象的 newInstance() 方法来创建Class对象对应类的实例。

eg：

public class Test02 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        Class stuClass = Class.forName("com.qizekj.clazz.Student");
        Object student = stuClass.newInstance();
        System.out.println(student);
    }
}

（2）先通过Class对象获取指定的 Constructor 对象，再调用 Constructor 对象的 newInstance() 方法来创建对象，这种方法可以用指定的构造器构造类的实例。

public class Test02 {
    public static void main(String[] args) throws Exception {
        //获取Student的Class对象
        Class stuClass = Class.forName("com.qizekj.clazz.Student");
        //通过Class对象获取指定的Constructor构造器对象
        Constructor constructor=stuClass.getConstructor();
        //根据构造器创建实例：
        Object obj = constructor.newInstance();
        System.out.println(obj);
    }
}

4、通过反射获取构造方法并使用

（1）批量获取的方法：

public Constructor[] getConstructors(); // 获取所有"公有的"构造方法
public Constructor[] getDeclaredConstructors() // 获取所有的构造方法(包括私有、受保护、默认、公有)

（2）单个获取的方法，并调用：

public Constructor getConstructor(Class... parameterTypes) // 获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class... parameterTypes) // 获取"某个构造方法"可以是私有的，或受保护、默认、公有；

（3）调用构造方法：

Constructor-->newInstance(Object... initargs)
  • newInstance 是 Constructor类的方法（管理构造函数的类）
  • api 的解释为：newInstance(Object… initargs) ，使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
  • 它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象，并为之调用。

eg：
Student类：共六个构造方法。

package com.cn.test;

public class Student {
    //---------------构造方法-------------------
    //（默认的构造方法）
    Student(String str){
        System.out.println("(默认)的构造方法 s = " + str);
    }
    //无参构造方法
    public Student(){
        System.out.println("调用了公有、无参构造方法执行了。。。");
    }
    //有一个参数的构造方法
    public Student(char name){
        System.out.println("姓名：" + name);
    }
    //有多个参数的构造方法
    public Student(String name ,int age){
        System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。
    }
    //受保护的构造方法
    protected Student(boolean n){
        System.out.println("受保护的构造方法 n = " + n);
    }
    //私有构造方法
    private Student(int age){
        System.out.println("私有的构造方法   年龄："+ age);
    }
}

public class ConstructorsTest {
    public static void main(String[] args) throws Exception {
        //1.加载Class对象
        Class clazz = Class.forName("com.qizekj.clazz.Student");

        //2.获取所有公有构造方法
        System.out.println("**********************获取所有公有构造方法*********************************");
        Constructor[] conArray = clazz.getConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }

        System.out.println("************获取所有的构造方法(包括：私有、受保护、默认、公有)***************");
        conArray = clazz.getDeclaredConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }

        System.out.println("*****************获取公有、无参的构造方法*******************************");
        Constructor con = clazz.getConstructor(null);
        //1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
        //2>、返回的是描述这个无参构造函数的类对象。
        System.out.println("con = " + con);
        //调用构造方法
        Object obj = con.newInstance();

        System.out.println("******************获取私有构造方法，并调用*******************************");
        con = clazz.getDeclaredConstructor(char.class);
        System.out.println(con);
        //调用构造方法
        con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
        obj = con.newInstance('男');

    }
}

打印结果：
在这里插入图片描述

5、获取成员变量并调用

（1）批量获取的方法：

Field[] getFields():  获取所有的"公有字段"；
Field[] getDeclaredFields():  获取所有字段，包括：私有、受保护、默认、公有；

（2）单个获取的方法，并调用：

public Field getField(String fieldName):  获取某个"公有的"字段；
public Field getDeclaredField(String fieldName):  获取某个字段(可以是私有的)。

（3）设置字段的值：

Field --> public void set(Object obj, Object value)

参数说明：

  1. obj:要设置的字段所在的对象；
  2. value:要为字段设置的值；

eg：
Student类：

package com.qizekj.clazz;

/**
 * @author chenqun
 * @date 2023/3/5 16:49
 */
public class Student2 {
    public String name;
    protected int age;
    char sex;
    private String phoneNum;

    public Student2(){}

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", phoneNum=" + phoneNum + "]";
    }
}

public class FieldsTest {
    public static void main(String[] args) throws Exception {
        //1.获取Class对象
        Class stuClass = Class.forName("com.qizekj.clazz.Student2");
        //2.获取字段
        System.out.println("************获取所有公有的字段********************");
        Field[] fieldArray = stuClass.getFields();
        for(Field f : fieldArray){
            System.out.println(f);
        }

        System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");
        fieldArray = stuClass.getDeclaredFields();
        for(Field f : fieldArray){
            System.out.println(f);
        }

        System.out.println("*************获取公有字段**并调用***********************************");
        Field f = stuClass.getField("name");
        System.out.println(f);

        //获取一个对象
        Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
        //为字段设置值
        f.set(obj, "qizekj");//为Student对象中的name属性赋值--》stu.name = "qizekj"
        //验证
        Student2 stu = (Student2)obj;
        System.out.println("验证姓名：" + stu.name);

        System.out.println("**************获取私有字段****并调用********************************");
        f = stuClass.getDeclaredField("phoneNum");
        System.out.println(f);

        f.setAccessible(true);//暴力反射，解除私有限定
        f.set(obj, "18355555555");
        System.out.println("验证电话：" + stu);
    }
}

打印结果：
在这里插入图片描述

6、获取成员方法并调用

（1）批量获取的方法：

public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）；
public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)

（2）单个获取的方法，并调用：

public Method getMethod(String name,Class<?>... parameterTypes)

参数说明：

  1. name : 方法名；
  2. Class … : 形参的Class类型对象。

（3）调用方法：

Method --> public Object invoke(Object obj,Object... args)

参数说明：

  1. obj : 要调用方法的对象；
  2. args: 调用方式时所传递的实参。

Student类：

package com.qizekj.clazz;

/**
 * @author chenqun
 * @date 2023/3/5 17:02
 */
public class Student3 {
    //**************成员方法***************//
    public void show1(String s){
        System.out.println("调用了：公有的，String参数的show1(): s = " + s);
    }
    protected void show2(){
        System.out.println("调用了：受保护的，无参的show2()");
    }
    void show3(){
        System.out.println("调用了：默认的，无参的show3()");
    }
    private String show4(int age){
        System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);
        return "abcd";
    }
}

public class MethodTest {
    public static void main(String[] args) throws Exception {
        //1.获取Class对象
        Class stuClass = Class.forName("com.qizekj.clazz.Student3");
        //2.获取所有公有方法
        System.out.println("***************获取所有的”公有“方法*******************");
        stuClass.getMethods();
        Method[] methodArray = stuClass.getMethods();
        for(Method m : methodArray){
            System.out.println(m);
        }
        System.out.println("***************获取所有的方法，包括私有的*******************");
        methodArray = stuClass.getDeclaredMethods();
        for(Method m : methodArray){
            System.out.println(m);
        }
        System.out.println("***************获取公有的show1()方法*******************");
        Method m = stuClass.getMethod("show1", String.class);
        System.out.println(m);
        //实例化一个Student对象
        Object obj = stuClass.getConstructor().newInstance();
        m.invoke(obj, "qizekj");

        System.out.println("***************获取私有的show4()方法******************");
        m = stuClass.getDeclaredMethod("show4", int.class);
        System.out.println(m);
        m.setAccessible(true);//解除私有限定
        Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
        System.out.println("返回值：" + result);
    }
}

打印结果：
在这里插入图片描述

7、获取main方法并调用

Student类：

package com.qizekj.clazz;

/**
 * @author chenqun
 * @date 2023/3/5 17:09
 */
public class Student4 {
    public static void main(String[] args) {
        System.out.println("Student4的 main 方法执行了。。。");
    }
}

public class MainTest {
    public static void main(String[] args) {
        try {
            //1、获取Student对象的字节码
            Class clazz = Class.forName("com.qizekj.clazz.Student4");
            //2、获取main方法
            Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，
            //3、调用main方法
            // methodMain.invoke(null, new String[]{"a","b","c"});
            //第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
            //这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
            methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一
            // methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

打印结果：
在这里插入图片描述

8、利用反射创建数值

数组在Java里是比较特殊的一种类型，它可以赋值给一个Object Reference。

public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> cls = Class.forName("java.lang.String");
        Object array = Array.newInstance(cls,25);
        //往数组里添加内容
        Array.set(array,0,"天天");
        Array.set(array,1,"小丽");
        Array.set(array,2,"阿奇");
        Array.set(array,3,"灰灰");
        Array.set(array,4,"莱德");
        //获取某一项的内容
        System.out.println(Array.get(array,3));
    }
}

9、通过反射运行配置文件内容

Student类：

package com.qizekj.clazz;

/**
 * @author chenqun
 * @date 2023/3/5 17:18
 */
public class Student5 {
    public void show(){
        System.out.println("is show()");
    }
}

配置文件 pro.txt 的内容：

className = com.qizekj.clazz.Student5
methodName = show

测试类：

package com.qizekj.clazz;

import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * @author chenqun
 * @date 2023/3/5 17:19
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        //通过反射获取Class对象
        Class stuClass = Class.forName(getValue("className"));//"com.qizekj.clazz.Student5"
        //2获取show()方法
        Method m = stuClass.getMethod(getValue("methodName"));//show
        //3.调用show()方法
        m.invoke(stuClass.getConstructor().newInstance());
    }

    //此方法接收一个key，在配置文件中获取相应的value
    public static String getValue(String key) throws IOException {
        Properties pro = new Properties();//获取配置文件的对象
        FileReader in = new FileReader("C:\\Users\\Administrator\\Desktop\\GitProjects\\chenqun_stu\\springstu\\src\\com\\qizekj\\clazz\\pro.txt");//获取输入流
        pro.load(in);//将流加载到配置文件对象中
        in.close();
        return pro.getProperty(key);//返回根据key获取的value值
    }
}

打印结果：
在这里插入图片描述

当我们升级这个系统时，不要Student5类，而需要新写一个Student6的类时，这时只需要更改 pro.txt 的文件内容就可以了。代码就一点不用改动。

10、通过反射越过泛型检查

泛型用在编译期，编译过后泛型擦除（消失掉），所以是可以通过反射越过泛型检查的。

package com.qizekj.clazz;

import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * @author chenqun
 * @date 2023/3/5 17:27
 */

/*
 * 通过反射越过泛型检查
 * 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
 */
public class Demo2 {
    public static void main(String[] args) throws Exception{
        ArrayList<String> strList = new ArrayList<>();
        strList.add("aaa");
        strList.add("bbb");

        //strList.add(100);
        //获取ArrayList的Class对象，反向的调用add()方法，添加数据
        Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
        //获取add()方法
        Method m = listClass.getMethod("add", Object.class);
        //调用add()方法
        m.invoke(strList, 100);

        //遍历集合
        for(Object obj : strList){
            System.out.println(obj);
        }
    }
}

打印结果：
在这里插入图片描述

吟诗作对歌一曲
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaWeb——反射
anrui0的博客
07-04 245
反射介绍 Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。Java的反射机制是通过对Java的字节码文件的剖析实现的，在编程中，我们编写的Java文件在javac的编译下会生成一个class文件，这个文件就是Java的字节码文件。字节码文件记录中对应编译类的类名，构造器名，变量名和方法名等。Java的反射机制正是的字节码文件的解析得...
java中的反射
痞子王的博客
04-03 207
typora-root-url: E:\learning\note\image 反射 反射是框架设计的灵魂，框架是一个半成品软件，程序员可以在框架的基础上进行软件开发，能够简化编码，优秀的框架还可以保证项目的安全性、可维护性。 一、概述 1.概念 将类的各个组成部分封装成其它对象。 2. java代码在计算机中执行经历的三个阶段 3.反射的好处 在程序的运行过程中去操作这些对象。 S...
Javaweb中提到的反射浅析（附源码）
weixin_34167819的博客
04-02 124
反射：一个jdk5.0的新特性，高级运用。在后期的框架中，这个是一大重点，现在估计我们都不会太多的接触他的。但是为了后面的铺垫，我想还是先了解一下： 先构造一个类，然后我们用反射来获取，调用里面的方法，属性package com.changeyd.test09;public class Person { // 属性 private S...
Java笔记：反射
FallingSkies的博客
09-09 172
框架：即半成品的软件，可以在其基础上进行软件开发，以简化代码 反射：将类的各个组成部分封装为其他对象，也即是反射机制 好处： 可以在程序运行过程中操作这些对象 可以解耦，提高程序的可扩展性 获取class对象的方式： 1.Class.forName(“全类名”):将字节码文件加载进内存，并返回Class对象 多用于配置文件，将类名定义在配置文件中。读取文件，加载类 2...
Web基础之Java中的反射机制
BlueSky_USC的博客
06-22 1351
WEB基础之Java中的反射 一、Java中的反射机制： 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都 能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 二、反射机制的功能： · 在运行时获取任意一个对象所属的类； · 在运行时构造任意一个
JavaWeb开发——JSP技术
03-24
此文章包含JSP简介、JSP运行原理、JSP标签与标签库及其使用、JSP的内置对象与作用域对象、EL表达式和MVC模式的简介，...适用于任何学习JavaWeb开发中，需要了解JSP技术的人群，希望这篇文章能对大家的学习有所帮助！
javaweb大型项目源码——游戏交易网
12-30
真实的大型java web项目，游戏交易网，想知道大型网站的构造和业务的朋友，这是一个不可多得的好资源哦。
MyEclipse——Java程序员开发工具必备
11-01
Eclipse是一个免费开源跨操作系统的IDE，它本身的功能非常有限，需要靠插件来扩展功能，以应对实际的开发需要。随着时间的推移，有人把最有用的一些插件优化整理打包形成一个插件集，并开始出售，这就是MyEclipse，...
01_javaweb_javaweb开发_specialdrp_java编程_ArtReviewservlet_
09-30
JAVAweb开发实例，使用Eclipse运行
JavaWeb 反射
weixin_46441425的博客
01-22 173
JavaWeb--反射
Ronin__L的博客
08-10 211
JavaWeb–反射 文章目录JavaWeb--反射反射框架:好处:获取class对象的方式:class对象功能∶Field :成员变量constructor:构造方法*Method :方法对象案例 反射 反射是框架设计的灵魂 Java 反射，就是在运行状态中。 获取任意类的名称、package信息、所有属性、方法、注解、类型、类加载器等 获取任意对象的属性，并且能改变对象的属性 调用任意对象的方法 判断任意一个对象所属的类 实例化任意一个类的对象 Java 的动态就体现在这。通过反射我们可以实现动态装配，
JavaWeb学习笔记——反射机制
TangXiaoPang的博客
01-27 329
    Junit的使用 单元测试 public void 方法名（）{} @Test @Ignore表示不进行单元测试 @before每个方法之前运行 @After每个方法之后运行 断言 Assert.asseertEquals 运行通过、运行不通过   枚举 jdk5.0新特性enum name ordinal valueOf values得到枚举数组 泛型的...
黑马Javaweb.1.2反射机制
青墟的CSDN博客
12-03 123
文章目录 本来一万行的代码，使用框架以后简化到一千行 要开发框架，需要学习反射。不开发框架，不用学反射 Java文件、字节码文件，都在硬盘上存储着，并没有进内存 需要把字节码文件加载进内存以后，才有对象。 Java中万物皆对象，在内存有一个class类对象描述这个字节码文件 把三个分别封装为不同的对象，并用fields数组来描述所有的变量 所有的Person对象，都是通过类对象创建出来的 这是...
构建自己的Java Web框架（三）之JAVA反射机制
人生苦短，我用... ...
06-28 1225
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
反射
weixin_44378636的博客
09-22 105
反射：框架设计的灵魂 对比： 框架：半成品软件。 可以在框架的基础上进行软件开发，简化编码 反射：将类的各个组成部分封装为其他对象，这就是反射机制 好处： 1. 可以在程序运行过程中，操作这些对象。 2. 可以解耦，提高程序的可扩展性。 获取Class对象的方式： 1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象 * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类 2. 类名.class：通过类名的属性class获取 * 多用于参数的传
Javaweb安全——Java反射
weixin_43610673的博客
04-01 2945
Java反射机制 Java反射(Reflection)是Java非常重要的动态特性，通过使用反射我们不仅可以获取到任何类的成员方法(Methods)、成员变量(Fields)、构造方法(Constructors)等信息，还可以动态创建Java类实例、调用任意的类方法、修改任意的类成员变量值等。Java反射机制是Java语言的动态性的重要体现，也是Java的各种框架底层实现的灵魂。 获取Class对象 Java反射操作的是java.lang.Class对象，所以我们需要先想办法获取到Class对象，通常我们有
java web 系列：反射
lkb的博客
05-01 531
什么是java的反射机制 java反射机制是在运行状态中，对任意一个类，都能够知道这个类的所有属性和方法；对任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能成为java语言的反射机制 java的反射机制的作用 用来编写一些通用性较高的代码或者框架的时候使用，在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系...
JavaWeb-基础知识02（反射）
一个小白
07-09 169
## 反射：框架设计的灵魂 * 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码 * 反射：将类的各个组成部分封装为其他对象，这就是反射机制 * 好处： 1. 可以在程序运行过程中，操作这些对象。 2. 可以解耦，提高程序的可扩展性。 * 获取Class对象的方式： 1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象 * 多用于配置文件，将类名定义在配置文件.
如何完整的做一个web项目，进阶篇（3）Java的反射机制
weixin_45691047的博客
05-11 245
一、反射机制概述 Java中的一个类由若干个对象组成,Field属性对象，Method方法对象，Constructor构造器对象，Modifier修饰符对象，数据类型对象，Void对象。 反射是类的自省，通过反射可以动态获取类中的方法、属性、构造方法等。 我们以往编写的代码都是编译期代码，这些代码是提前写好，固定的代码，反射在运行期执行的代码，使用反射编写的代码中是没有具体定义那个对象的，它会根据需要在运行期自动的创建类的对象并调用相关方法。 我们可以通过反射来开发通用功能的方法或类；目前所使用所有企业级
JavaWeb开发经典题目，挑战你的技术水平
最新发布
11-09
本资源是一份精心设计的JavaWeb开发经典题目集，针对JavaWeb应用开发的中级水平学习者。它包含丰富的单选题、填空题、判断题和编程题，旨在帮助学习者巩固基础的Java编程知识，如数据库操作（如MySQL查询）和SQL语法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吟诗作对歌一曲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值