Java基础 - 反射篇 - 反射机制、Class类详解

最新推荐文章于 2022-05-28 10:50:11 发布
最新推荐文章于 2022-05-28 10:50:11 发布
阅读量273 收藏
点赞数
分类专栏： 笔记 成长阶段 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39123467/article/details/123126893
版权

文章目录

反射机制

需求引出反射

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

classfullpath = com.taotao.Cat
method = hi

无反射情况(代码测试)

package com.taotao.reflection.question;

import com.taotao.Cat;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

/**
 * Create By 刘鸿涛
 * 2022/2/22 12:42
 * 反射问题的引入
 */
public class ReflectionQuestion {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //根据配置文件 re.properties 指定信息，创建Cat对象并调用方法hi
        //思考

        //传统方式 new 对象 -> 调用方法
        Cat cat = new Cat();
        cat.hi();

        //IO流读取方式
        //1.使用Properties类，可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath = properties.getProperty("classfullpath").toString();
        String method = properties.getProperty("method").toString();
        System.out.println("classfullpath = " + classfullpath);
        System.out.println("method = " + method);
        //2.创建对象，传统的方法，行不通
        //new classfullpath();
    }
}
结论

这样的需求在学习框架时特别多，即通过外部文件配置，在不修改源码情况下，来控制程序，也符合设计模式的ocp原则（开闭原则：不修改源码，开扩容功能）

使用反射解决（练习）

cat类

package com.taotao;

/**
 * Create By 刘鸿涛
 * 2022/2/22 12:40
 */
public class Cat {
    private String name = "招财猫";
    public void hi(){
        System.out.println("hi" + name);
    }
    public void cry(){  //常用方法
        System.out.println(name + "喵喵叫");
    }
}

re.properties文件

classfullpath = com.taotao.Cat
method = cry

ReflectionQuestion

package com.taotao.reflection.question;

import com.taotao.Cat;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * Create By 刘鸿涛
 * 2022/2/22 12:42
 * 反射问题的引入
 */
public class ReflectionQuestion {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //根据配置文件 re.properties 指定信息，创建Cat对象并调用方法hi
        //思考

        //传统方式 new 对象 -> 调用方法
//        Cat cat = new Cat();
//        cat.hi();

        //IO流读取方式
        //1.使用Properties类，可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath = properties.getProperty("classfullpath").toString();
        String methodName = properties.getProperty("method").toString();
        System.out.println("classfullpath = " + classfullpath);
        System.out.println("method = " + methodName);
        //2.创建对象，传统的方法，行不通
        //new classfullpath();

        //使用反射解决
        //(1)加载类，返回Class类型的对象
        Class cls = Class.forName(classfullpath);
        //(2)通过 cls 得到你家在的类 com.taotao.Cat 的对象实例
        Object o = cls.newInstance();
        //不需要强转，依然是Cat
        System.out.println(o.getClass());
        //(3)通过 cls 得到你加载的类 com.taotoa.Cat 的 methodName "hi" 的方法对象
        //    即：在反射中，可以把方法视为对象（万物皆对象）
        Method method1 = cls.getMethod(methodName);
        //（4）通过method1调用方法
        System.out.println("=========================");
        method1.invoke(o); //传统方法 对象.方法（），反射机制 方法.invoke(对象)

    }
}

反射机制

Java Reflection

1．反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息(比如成员变量，构造器，成员方法等等),并能操作对象的属性及方法。反射在设计模式和框架底层都会用到

2.加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象)，这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构,所以,形象的称之为:反射

img

Java反射机制原理（图）

请添加图片描述

Java反射机制可以完成

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

反射相关的主要类

java.lang.Class

代表一个类，Class对象表示某个类加载后在堆中的对象

java.lang.reflect.Method

代表类的方法，Method对象表示某个类的方法

java.lang.reflect.Field

代表类的成员变量，Filed对象表示某个类的成员变量

java.lang.reflect.Constructor

代表类的构造方法，Constructor对象表示构造器

案例演示（练习）

Cat类

package com.taotao;

/**
 * Create By 刘鸿涛
 * 2022/2/22 12:40
 */
public class Cat {
    public String name = "招财猫";
    public int age = 15;

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

    public Cat() {
    }

    public void hi(){
        System.out.println("hi" + name);
    }
    public void cry(){  //常用方法
        System.out.println(name + "喵喵叫");
    }
}

Reflection01.java

package com.taotao.reflection;

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

/**
 * Create By 刘鸿涛
 * 2022/2/23 16:08
 */
public class Reflection01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath = properties.getProperty("classfullpath").toString();
        String methodName = properties.getProperty("method").toString();

        //使用反射解决
        //(1)加载类，返回Class类型的对象
        Class cls = Class.forName(classfullpath);
        //(2)通过 cls 得到你家在的类 com.taotao.Cat 的对象实例
        Object o = cls.newInstance();
        //不需要强转，依然是Cat
        System.out.println(o.getClass());
        //(3)通过 cls 得到你加载的类 com.taotoa.Cat 的 methodName "hi" 的方法对象
        //    即：在反射中，可以把方法视为对象（万物皆对象）
        Method method1 = cls.getMethod(methodName);
        //（4）通过method1调用方法
        System.out.println("=========================");
        method1.invoke(o); //传统方法 对象.方法（），反射机制 方法.invoke(对象)

//        java.lang.reflect.Field 代表类的成员变量，Filed对象表示某个类的成员变量
        //得到name字段
        //getFiled不能得到私有的属性，所以我们把前面的Cat类的name改为共有的
        Field nameField = cls.getField("name");
        System.out.println(nameField.get(o));       //传统写法 对象.成员变量，反射：成员变量对象.get(对象)
        Field ageField = cls.getField("age");
        System.out.println(ageField.get(o));

//        java.lang.reflect.Constructor 代表类的构造方法，Constructor对象表示构造器
        //得到无参
        Constructor constructor = cls.getConstructor(); //()中可以指定构造器参数类型，返回无参构造器
        System.out.println("========无参=======");
        System.out.println(constructor);      //Cat()
        //为了更好的演示，我们写一个有参构造器，当然我们还需要加上无参构造器
        //得到有参
        Constructor constructor1 = cls.getConstructor(String.class);//这里传入的Stirng.class 就是String类的Class对象
        System.out.println("===========有参===========");
        System.out.println(constructor1);   //Cat(String name)

    }
}

反射的优点和缺点

优点

可以动态的创建和使用对象（也是框架底层核心），使用灵活，没有反射机制，框架技术就失去底层支撑

使Java成为一款伪动态语言

缺点

使用反射基本是解释执行，对执行速度有影响

应用实例

cat类

package com.taotao;

/**
 * Create By 刘鸿涛
 * 2022/2/22 12:40
 */
public class Cat {
    public String name = "招财猫";
    public int age = 15;

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

    public Cat() {
    }

    public void hi(){
//        System.out.println("hi" + name);
    }
    public void cry(){  //常用方法
        System.out.println(name + "喵喵叫");
    }
}

Reflection2.java

package com.taotao.reflection;

import com.taotao.Cat;

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

/**
 * Create By 刘鸿涛
 * 2022/2/23 16:58
 * 测试反射调用的性能，和优化方案
 */
public class Reflection02 {
    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        m1();
        m2();
    }
    //传统方法来调用hi
    @SuppressWarnings({"all"})
    public static void m1(){
        Cat cat = new Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++){
            cat.hi();
        }
        long end = System.currentTimeMillis();
        System.out.println("m1方法 耗时=" + (end - start));
    }

    //反射机制调用方法hi
    @SuppressWarnings({"all"})
    public static void m2() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {

        Class cls = Class.forName("com.taotao.Cat");        //不用io读了，这里直接读路径
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++){
            hi.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("===================================");
        System.out.println("m2方法 耗时=" + (end - start));
    }
}

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

  1. Method和Field、Constructor对象都有setAccessible（）方法
  2. setAccessible作用是启动和禁用访问安全检查的开关
  3. 参数值为true表示 反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查
    @SuppressWarnings({"all"})
    public static void m2() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {

        Class cls = Class.forName("com.taotao.Cat");        //不用io读了，这里直接读路径
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");

        //c
        hi.setAccessible(true); //取消方法

        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++){
            hi.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("===================================");
        System.out.println("m2方法 耗时=" + (end - start));
    }

Class类

详细介绍

  • Class也是类,因此也继承Object类[类图]

请添加图片描述

  • Class类对象不是new出来的，而是系统创建的[演示]
package com.taotao.reflection.class_;

import com.taotao.Cat;

/**
 * Create By 刘鸿涛
 * 2022/2/24 16:21
 * 对Class类特点的梳理
 */
public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //Class类对象不是new出来的，而是系统创建的
        //(1)传统new对象
        /*
        ClassLder类
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                return loadClass(name, false);
            }
        * */
        Cat cat = new Cat();
        //(2)反射方式,刚才没有debug到 classLoader类的 loadClass，原因是，没有注销 Cat cat = new Cat
        /*
        ClassLoader类，仍然是通过ClassLoader类加载Cat类的Class对象
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                return loadClass(name, false);
            }
        * */
        Class<?> aClass = Class.forName("com.taotao.Cat");

    }
}
  • 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次[演示]
package com.taotao.reflection.class_;

import com.taotao.Cat;

/**
 * Create By 刘鸿涛
 * 2022/2/24 16:21
 * 对Class类特点的梳理
 */
public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //Class类对象不是new出来的，而是系统创建的
        //(1)传统new对象
        /*
        ClassLder类
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                return loadClass(name, false);
            }
        * */
        Cat cat = new Cat();
        //(2)反射方式,刚才没有debug到 classLoader类的 loadClass，原因是，没有注销 Cat cat = new Cat
        /*
        ClassLoader类，仍然是通过ClassLoader类加载Cat类的Class对象
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                return loadClass(name, false);
            }
        * */
        Class<?> aClass = Class.forName("com.taotao.Cat");

    }
}
  • 每个类的实例都会记得自己是由哪个Class实例所生成
        //3.对于某个类的Class类对象，在内存中只有一份，因为类只加载一次[演示]
        Class<?> aClass1 = Class.forName("com.taotao.Cat");
        System.out.println(aClass.hashCode());  //460141958
        System.out.println(aClass1.hashCode()); //460141958
        //比如我新建一个类，并加载类对象
        Class<?> aClass2 = Class.forName("com.taotao.Dog");
        System.out.println(aClass2.hashCode()); //1163157884
  • 通过Class可以完整地得到一个类的完整结构,通过一系列API

请添加图片描述

  • Class对象是存放在堆的

请添加图片描述

  • 类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括方法代码,变量名，方法名，访问权限等等)https://www.zhihu.com/question/38496907【示意图】

请添加图片描述

当我们读取字节码文件Cat.class文件后，我们的虚拟机先在内存“方法区”生成“Cat类的字节码二进制文件”，然后在内存堆中产生Class类对象（此Class是一个类的名称），我们的方法区是二进制数据，不方便使用者理解，而我们的堆中数据是一种数据结构，更方便使用者理解

常用方法应用实例

Car类

package com.taotao;

/**
 * Create By 刘鸿涛
 * 2022/2/24 17:06
 */
public class Car {
    public String brand = "宝马";
    public int price = 500000;
    public String color = "白色";

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

常用方法练习

package com.taotao.reflection.class_;

import com.taotao.Car;
import jdk.nashorn.internal.ir.CallNode;

import java.lang.reflect.Field;

/**
 * Create By 刘鸿涛
 * 2022/2/24 17:07
 * 演示Class类的常用方法
 */
public class Class02 {
    @SuppressWarnings({"all"})
    //ClassNotFoundException异常是路径写错时异常
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        String classAllPath = "com.taotao.Car";
        //1.获取Car类 对应的 Class对象
        //<?>表示不确定的Java类型
        Class<?> aClass = Class.forName(classAllPath);
        //2.输出aClass
        System.out.println(aClass); //显示aClass对象，是哪个类的Class对象   com.taotao.Car
        System.out.println(aClass.getClass());  //我们这个Class类也可以得到它对应的Class，输出运行类型为 java.lang.Class

        //3.得到包名
        System.out.println(aClass.getPackage().getName());  //com.taotao

        //4.得到类名
        System.out.println(aClass.getName());   //com.taotao.Car

        //5.通过aClass创建对象实例
        //方式一
        Object o = aClass.newInstance();
        //方式二
        Car car = (Car)aClass.newInstance();
        System.out.println(o);  //car.toString()  Car{brand='宝马', price=500000, color='白色'}
        System.out.println(car);    //car.toString()  Car{brand='宝马', price=500000, color='白色'}

        //6.通过反射获取属性，比如得到brand
        Field brand = aClass.getField("brand");
        System.out.println(brand.get(car)); //宝马        //注意，这里必须是公开属性

        //7.通过反射给属性赋值
        brand.set(car,"奔驰");
        System.out.println(brand.get(car)); //奔驰

        //8.遍历所有属性
        Field[] fields = aClass.getFields();
        for(Field f: fields){
            System.out.println(f.getName());
        }

    }
}

获取Class类对象

前提1

已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName(获取，可能抛出ClassNotFoundException，实例:Class cls1 =Class.forName("java.lang.Cat”);

应用场景

多用于配置文件,读取类全路径，加载类.

案例演示
        //Class.forName
        String classAllPath = "com.taotao.Car"; //通过读取配置文件获取
        Class<?> aClass = Class.forName(classAllPath);
        System.out.println(aClass); //com.taotao.Car

前提2

若已知具体的类，通过类的class 获取，该方式最为安全可靠，程序性能最高实例: Class cls2 = Cat.class;

应用场景

多用于参数传递，比如通过反射得到对应构造器对象.

案例演示
        //类名.class,应用场景：多用于参数传递
        //方式一
        System.out.println(Car.class); //com.taotao.Car
        //方式二
        Class aClass1 = Car.class;
        System.out.println(aClass1);    //com.taotao.Car

前提3

前提:已知某个类的实例，调用该实例的getClass()方法获取Class对象，实例:Class clazz =对象.getClass0;

应用场景

通过创建好的对象，获取Class对象.

案例演示
         //对象.getClass(),应用场景，有对象实例
        Car car = new Car();
        Class aClass2 = car.getClass();
        System.out.println(aClass2);    //com.taotao.Car

其他方式

ClassLoader cl =对象.getClass().getClassLoader();

        //通过类加载器【4种】来获取到类的Class对象
        //（1）得到类加载器 car
        ClassLoader classLoader = car.getClass().getClassLoader();

Class clazz4 = cl.loadClass(“类的全类名”);

	  //通过类加载器得到class对象
        Class aClass3 = classLoader.loadClass(classAllPath);
        System.out.println(aClass3);    //com.taotao.Car

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

Class cls = 基本数据类型.class

        //基本数据(int, char,boolean,float,double,byte,long,short)按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass); //int

基本数据类型对应的包装类，可以通过.type 得到Class类对象

Class cls = 包装类.TYPE

        //基本数据类型对应的包装类，可以通过.type 得到Class类对象
        Class<Integer> type = Integer.TYPE;
        Class<Character> type1 = Character.TYPE;
        System.out.println(type);   //int
        System.out.println(type1);  //char

        System.out.println(integerClass.hashCode());    //460141958
        System.out.println(type.hashCode());        //460141958

哪些类型有Class对象

例如

  1. 外部类，成员内部类，静态内部类，局部内部类，匿名内部类
  2. interface：接口
  3. 数组
  4. enum：枚举
  5. annotation：注解
  6. 基本数据类型
  7. void

应用实例

package com.taotao.reflection.class_;

import java.io.Serializable;

/**
 * Create By 刘鸿涛
 * 2022/2/25 9:52
 */
public class AllTypeClass {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Class<String> cls1 = String.class; //外部类
        Class<Serializable> cls2 = Serializable.class; //接口
        Class<Integer[]> cls3 = Integer[].class;  //数组
        Class<float[][]> cls4 = float[][].class; //二维数组
        Class<Deprecated> cls5 = Deprecated.class;   //注解
        Class<Thread.State> cls6 = Thread.State.class;    //枚举（线程也是一个枚举）
        Class<Long> longClss = long.class; //基本数据类型
        Class<Void> voidCla = void.class; //void
        Class<Class> classClass = Class.class;  //类

        System.out.println(cls1);//class java.lang.String
        System.out.println(cls2);//interface java.io.Serializable
        System.out.println(cls3);//class [Ljava.lang.Integer;
        System.out.println(cls4);//class [[F
        System.out.println(cls5);//interface java.lang.Deprecated
        System.out.println(cls6);//class java.lang.Thread$State

    }
}
鬼鬼骑士
关注
专栏目录
Java Class类与反射机制详解
meiyongdesan的博客
08-04 414
概述 反射是 java 编程语言所具备的一种高级特性：对于任何一个类，都能知道这个类的属性和方法；对于任何对象，都能调用它的方法和属性，我们把这种动态获取属性信息以及动态调用对象方法的方式称为 反射机制。由于功能的强大性，反射在很多开源框架或是类库中获得非常广泛的使用，本篇博客我就来简单整理一下 java 反射相关的知识。 Java 反射 本篇博客我打算分以下几个模块展开： Java Class 类 Java Class 类 Java 反射基于 Class 类对象实现，这里我首先整理 Class
java基础之反射类型Type
小明的博客
09-08 282
Java在加入泛型之后，仅仅Class已经不足以描述数据的类型了，比如List<String>类型的数据，其Class的类型为List.class，但是其类型包含了泛型参数，所以java引入了Type类型来描述泛型类型。除了泛型类型，还有数组格式的数据，其类型也包含两部分，一部分是数组对象本身的class，另外一部分是数组中数据的类型。本文会详细介绍JavaType中的各种类型，分析这些类型的使用方法。 Type介绍 Type是Java 编程语言中所有类型的公共高级接口，也就是Java中所有&q
Java学习之路（六十三）| 反射（一）初步了解反射
weixin_45904051的博客
11-10 396
反射的引入、反射机制、反射相关类、反射调用优化（关闭访问检查）
Java基础篇--反射
weixin_61500949的博客
05-28 118
类加载 一、类加载的概念： 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。如果不出现意外情况， jvm将会练习完成这三个步骤，所以有时也把这三个步骤统称为类加载或类的初始化 二、类的加载： 1.就是指将class文件读入内存，并为之创建一个java.lang.Class对象 2.任何类被使用时，系统都会为之建立一个java.lang.class对象 三、类的连接： 1.验证阶段：用于检验被加载的类是否是正确
java 基础篇--- 反射
weixin_62580505的博客
03-03 368
一、 什么是反射 Java的反射机制(reflection) 中是很重要的机制。在运行中状态中对于任意一个类都能知道它的属性、方法。对于任意一个类，都能够调用任意方法和属性。既然任意调用那也能改动，这种动态获取信息和动态调用方法的功能称为java的反射机制。 二、用途 1、众所周知，在实际情况下多次遇见其属性是私有，只面向系统进行开放，这时候可以用Java的反射机制来获取所需的私有成员和方法。 2、反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有类Bean交给spring容器管
Java 基础(7-8) - 反射机制详解.pdf
06-29
"Java 反射机制详解" Java 反射机制是在运⾏状态中，对于任意⼀个类，都能够知道这个类的所有属性和⽅法；对于任意⼀个对象，都能够调⽤它的任意⼀个⽅法和属性；这种动态获取的信息以及动态调⽤对象的⽅法的功能...
大学课程讲义-Java基础-反射.pptx
最新发布
08-14
Constructor、Method、Field类是Java反射机制中的三个重要类，用于描述类的构造器、方法和字段。 * Constructor类：用于描述类的构造器，提供了newInstance()方法，可以创建类的实例。 * Method类：用于描述类的...
JAVA基础-反射-枚举
02-19
### JAVA基础-反射-枚举知识点详解 #### 一、反射概述 反射是Java语言提供的一种能在运行时分析类和对象的能力。通过反射，我们可以在程序运行时动态地获取类的信息（如类名、方法、构造函数等）并操作这些信息。 ...
Java 反射机制实例详解
08-29
Java 反射机制实例详解是一种动态语言机制，允许在程序运行时加载、探知和使用编译期间完全不知道的类、生成其对象实体，调用其方法或者对属性设值。下面是 Java 反射机制实例详解的知识点： 1. 反射机制的概念 ...
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
Java【反射】
zhsihui429的博客
01-24 2905
目录 1、什么是反射 2、必须一定了解的基础 3、怎么运用反射 1、什么是反射 反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并获得类信息。 举个栗子
JAVA础--利用java反射机制绕过编译时的类型检查和访问控制检查
penriver的博客
07-05 452
使用Java反射API，可以做到如下： 绕过编译时的类型检查，在List中添加不同类型的元素 绕过编译时的类型检查，在map中添加其它类型的元素 利用反射调用对象的私有方法 利用反射完成对私有成员变量的重新赋值 示例代码如下: class ReflectionTest { public static void main(String[] args) throws Exception { //在List中添加不同类型的元素 ArrayList<Integer
java class类 反射_Java基础--反射之Class类
weixin_35430535的博客
02-16 129
一、Class类Class是一个类对象照镜子后可以得到的信息：某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。Class 对象只能由系统建立对象一个类在 JVM 中只会有一个Class实例每个类的实例都会记得自己是由哪个 Class 实例所生成(1)获取 Class ...
java反射应用_详解Java反射各种应用
weixin_32021519的博客
02-22 201
Java除了给我们提供在编译期得到类的各种信息之外，还通过反射让我们可以在运行期间得到类的各种信息。通过反射获取类的信息，得到类的信息之后，就可以获取以下相关内容：Class对象构造器变量方法私有变量与私有方法注解泛型数组本文也将从上面几个方面来介绍Java反射。本文涉及的所有代码均在反射代码首先放出一个Java类作为反射的研究对象，类的内容如下：public abstract class Fat...
Python学习笔记-类
awentangtang9的博客
03-06 199
创建类 class 之后为类的名称并以冒号结尾 class 类名： 创建实例对象 类
JAVA学习之反射（1）：Class类和java.lang.reflect包的使用
欢迎来到Jimmy的博客
12-20 2477
一，能够分析类能力的程序称为“反射”，反射库（java.lang.reflect）提供了精心设计的工具集，以便编写能够动态操作Java代码的程序。 二，在程序运行期间，java运行时系统始终为所有的对象维护一个类型标识。这个标识跟踪着每个对象所属的类。虚拟机利用该标识选择相应的方法执行。可以通过专门的Java类访问这些信息。保存这些信息的类被称为Class类。 如同一个Person对象
java object妙用,java11教程--类AccessibleObject用法
weixin_42310348的博客
03-13 393
不推荐使用此方法，因为它的名称暗示它在实际指示是否抑制了对Java语言访问控制的检查时检查反射对象是否可访问。如果此元素上存在指定类型的注释，则返回true，否则返回false。将此反射对象的accessible标志设置为指示的布尔值。通过单个安全检查为效率设置反射对象数组的accessible标志的便捷方法(为了提高效率)。设置accessible标志这反映了反对true如果可能的话。构造函数：...
反射的作用、反射方法调用与普通方法性能测试
Gakooon的博客
12-14 367
反射 通过反射可以做的事： 获取任意类的名称、package信息、所有属性、方法、注解、类型、类加载器等 public class 1213lianxi { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, ...
JAVA反射之取消对访问控制检查
name_liv的专栏
02-10 3786
package test; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; /** * AccessibleObject类是Field、Method、和Constructor对象的基类。它提供了将反射的对象标
Java反射机制详解：Class类与实例化对象
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时检查和操作类、接口、字段和方法的信息。这个机制赋予了Java动态性，使得程序能够在运行时发现并操作类的内部结构，极大地提高了代码的灵活性和可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

鬼鬼骑士

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

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

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

打赏作者

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

抵扣说明：

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

余额充值