反射(reflection)

最新推荐文章于 2024-07-24 21:47:59 发布
最新推荐文章于 2024-07-24 21:47:59 发布
阅读量460 收藏 1
点赞数 1
分类专栏： JavaSE 文章标签： java 后端 反射 javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47200222/article/details/123046857
版权

反射(reflection)

文章目录

1.反射机制

1.1 反射机制原理示意图

reflection

1.2 反射机制功能

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

1.3 反射相关类的主要类

类名作用
java.lang.Class代表一个类，Class对象表示某个类加载后在堆中的对象
java.lang.reflect.Method代表类的方法,Method对象表示某个类的方法
java.lang.reflect.Field代表类的成员变量,Field对象表示某个类的成员变量
java.lang.reflect.Constructor代表类的构造方法,Constructor对象表示构造器

1.4 反射优点和缺点

  1. 优点:可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制,框架技术就失去底层支撑。
  2. 缺点:使用反射基本是解释执行，对执行速度有影响。

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

  1. Method和Field、Constructor对象都有setAccessible()方法
  2. setAccessible作用是启动和禁用访问安全检查的开关
  3. 参数值为true表示反射的对象在使用时取消访问检查,提高反射的效率。参数值为false则表示反射的对象执行访问检查。

method.setAccessible(true); //在反射调用方法时，取消访问检查

2.Class类

bbf3086d27314f53806fb5b6425d4334

2.1 基本介绍

  1. Class也是类,因此也继承Object类
  2. Class类对象不是new出来的,而是系统创建的
  3. 对于某个类的实例都会记得自己是由哪个Class实例所生成
  4. 每个类的实例都会记得自己是由哪个Class实例所生成
  5. 通过Class对象可以完整地得到一个类的完整结构(通过一系列API)
  6. Class对象是存放在堆的
  7. 类的字节码二进制数据，是放在方法区的，有的地方为类的元数据(包括 方法代码，变量名，方法名，访问权限等等)

2.2 常用方法

car类

public class Car {

    public String brand = "宝马";
    public int price = 50000;
    public String color = "白色";

    public void Call() {
        System.out.println("小车呼呼叫。。。");
    }

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

class02

/*
 * class常用方法演示
 */
public class Class02 {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, NoSuchMethodException {

        String classAllPath = "com.xujc.Car";
        //1. 获取到Car类,对应的 Class对象
        //<?> 表示不确定的Java类型
        Class<?> cls = Class.forName(classAllPath);
        //2. 输出cls
        System.out.println(cls);//显示cls对象，是哪个类的Class对象 com.xujc.Car
        System.out.println(cls.getClass());//输出cls运行类型 java.lang.Class

        //3.得到包名
        System.out.println(cls.getPackage().getName()); //包名

        //4.得到全类名
        System.out.println(cls.getName());
        //5.通过cls创建对象实例
        Car car = (Car) cls.newInstance();
        System.out.println(car);//car.toString()
        //6.通过反射获取属性
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));
        //7.通过反射给属性赋值
        brand.set(car, "奔驰");
        System.out.println(brand.get(car));
        //8.我希望大家可以得到所有的属性(字段)
        System.out.println("=====所有的字段属性====");
        Field[] fields = cls.getFields();
        for (Field f : fields) {
            System.out.println(f.getName()); //名称
        }


    }
}

3.获取Class类对象

请添加图片描述

/**
 * 演示得到Class对象的各种方式(6)
 */
public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {
        //1. Class.forName
        String classAllPath = "com.xujc.Car"; //通过读取配置文件获取
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        //2. 类名.class , 应用场景: 用于参数传递
        Class cls2 = Car.class;
        System.out.println(cls2);

        //3. 对象.getClass(), 应用场景，有对象实例
        Car car = new Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);

        //4. 通过类加载器【4种】来获取到类的Class对象
        //(1)先得到类加载器 car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);

        //cls1 , cls2 , cls3 , cls4 其实是同一个对象
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());

        //5. 基本数据(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

        //6. 基本数据类型对应的包装类，可以通过 .TYPE 得到Class类对象
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE; //其它包装类BOOLEAN, DOUBLE, LONG,BYTE等待
        System.out.println(type1);

        System.out.println(integerClass.hashCode());//
        System.out.println(type1.hashCode());//两者是一样的
    }
}

4.类加载

  • 基本说明

    反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。

    1. 静态加载:编译时加载相关的类，如果没有则报错，依赖性太强

    2. 动态加载:运行时加载需要的类，如果运行时不用该类,即使不存在该类，也不会报错，降低了依赖性

  • 类加载时机

    1. 当创建对象时(new) //静态加载
    2. 当子类被加载时,父类也加载 //动态加载
    3. 调用类中的静态成员时 //静态加载
    4. 通过反射 //动态加载

  • 类加载3个阶段(5个子阶段)

    1. 加载阶段(Loading)

      JVM在该阶段的主要目的是将字节码从不同的数据源(可能是class文件、也可能是jar包，甚至网络)

      转化成二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象

    2. 连接阶段-验证(verification)

      • 目的是为了是确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机

        自身的安全

      • 包括: 文件格式验证(是否以魔数 oxcafebabe开头)、元数据验证、字节码验证和

    3. 连接阶段-准备(preparation)

      • JVM会在该阶段对静态变量，分配内存并初始化(对应数据类型的默认初始值，如0、0L、null、false等)。

        这些变量所使用的内存都将在方法区中进行分配

    4. 链接阶段-解析(Resolution)

      • 虚拟机将常量池内的符号引用替换为直接引用的过程。

    5. 初始化(Initialization)

      • 到初始化阶段，才真正开始执行类中定义的Java程序代码,此阶段是执行()方法的过程

      • ()方法是由编译器按语句在源文件中出现的顺序,依次自动收集类中的所有静态变量的

        赋值动作和静态代码块中的语句,并进行合并。

      • 虚拟机会保证一个类()方法在多线程环境中被正确的加锁、同步，如果多个线程同时去

        初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程需要阻塞等待，

        直到活动线程执行()方法完毕

请添加图片描述

5.通过反射获取类的结构信息

a> java.lang.Class类

api作用
getName获取全类名
getSimpleName获取简单类名
getFields获取所有public修饰的属性，包括本类以及父类的
getDeclaredFields获取本类中所有属性
getMethods获取所有public修饰的方法,包括本类以及父类的
getDeclaredMethods获取本类中所有方法
getConstructors获取本类所有public修饰的构造器
getDeclaredConstructors获取本类中所有构造器
getPackage以Package形式返回 包信息
getSuperClass以Class形式返回父类信息
getInterfaces以Class[]形式返回接口信息
getAnnotations以Annotation[]形式返回注解信息

b> java.lang.reflect.Field类

  1. getModifiers: 以int形式返回修饰符

    [说明:默认修饰符是 0,public是 1，private是 2,protect是 4,static是 8,final是 16，如果是两个修饰符则相加

    如public static返回的值是1+8=9]

  2. getType:以Class形式返回类型

  3. getName:返回属性名

c> java.lang.reflect.Method类

  1. getModifiers:以int形式返回修饰符

    [说明:默认修饰符是 0,public是 1，private是 2,protect是 4,static是 8,final是 16]

  2. getReturnType: 以Class形式获取 返回类型

  3. getName：返回方法名

  4. getParameterTypes:以Class[]返回参数类型数组

d> java.lang.reflect.Constructor类

  1. getModifiers:以int形式返回修饰符
  2. getName:返回构造器(全类名)
  3. getParameterTypes:以Class[]返回参数类型数组

e> 实例演示

/**
 * 通过反射获取类的结构信息
 */
public class ReflectionUtils {

    public static void main(String[] args) {

    }

    //第一组
    @Test
    public void api_01() throws ClassNotFoundException, NoSuchMethodException {

        //得到Class对象
        Class<?> personClass = Class.forName("com.xujc.reflection.Person");
        //| getName                 | 获取全类名                                     |
        System.out.println(personClass.getName());
        //| getSimpleName           | 获取简单类名                                   |
        System.out.println(personClass.getSimpleName());
        //| getFields               | 获取所有public修饰的属性，包括本类以及父类的   |
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println("本类以及父类的属性" + field.getName());
        }
        //| getDeclaredFields       | 获取本类中所有属性                             |
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有属性=" + declaredField.getName());
        }

        //| getMethods              | 获取所有public修饰的方法,包括本类以及父类的    |
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println("本类以及父类的方法=" + method.getName());
        }
        //        | getDeclaredMethods      | 获取本类中所有方法                             |
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类所有的方法" + declaredMethod);
        }
        // | getConstructors         | 获取所有public修饰的构造器，包括本类 |
        Constructor<?>[] constructors = personClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("本类的构造器=" + constructor.getName());
        }

        //         | getDeclaredConstructors | 获取本类中所有构造器                           |
        Constructor<?>[] declaredConstructors = personClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类的所有方法" + declaredConstructor);
        }
        //        | getPackage              | 以Package形式返回 包信息                       |
        System.out.println(personClass.getPackage());
        //        | getSuperClass           | 以Class形式返回父类信息                        |
        Class<?> superclass = personClass.getSuperclass();
        System.out.println("父类的class对象" + superclass);
        //         | getInterfaces           | 以Class[]形式返回接口信息                      |
        Class<?>[] interfaces = personClass.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("接口信息=" + anInterface);
        }
        //        | getAnnotations          | 以Annotation[]形式返回注解信息                 |
        Annotation[] annotations = personClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息=" + annotation); //注解
        }
    }

    @Test
    public void api_02() throws ClassNotFoundException, NoSuchMethodException {

        //得到Class对象
        Class<?> personCls = Class.forName("com.xujc.reflection.Person");
        //getDeclaredFields: 获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有属性=" + declaredField.getName()
                    + " 该属性的修饰符=" + declaredField.getModifiers()
                    + " 该属性的类型=" + declaredField.getType());
        }

        //getDeclaredMethods: 获取所有public修饰的方法,包括本类以及父类的
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类以及父类的方法=" + declaredMethod.getName() +
                    " 该方法的访问修饰符值=" + declaredMethod.getModifiers() +
                    " 该方法返回类型" + declaredMethod.getReturnType());

            //输出当前这个方法的形参数组情况(无参不输出)
            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("该方法的形参类型=" + parameterType);
            }
        }

        //getDeclaredConstructors:获取本类中所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类的所有方法" + declaredConstructor);

            Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("该构造器的形参类型=" + parameterType);
            }
        }

    }
}

class A {
    public String hobby;

    public void hi() {
    }

    //构造器
    public A() {
    }

    public A(String hobby) {
        this.hobby = hobby;
    }
}

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() {
    }

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

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

    //方法
    public void m1(String name, int age, double sal) {

    }

    protected String m2() {
        return null;
    }

    void m3() {

    }

    private void m4() {

    }
}

6.通过反射创建对象

  1. 方式一: 调用类中的public修饰的无参构造器
  2. 方式二: 调用类中的指定构造器
  3. Class类相关方法
    • newInstance:调用类中的无参构造器，获取对应类的对象
    • getConstructor(Class…clazz):根据参数列表,获取对应的public构造器对象
    • getDecalaredConstructor(Class…clazz):根据参数列表，获取对应的所有构造器对象
  4. Constructor相关方法
    • setAccessible:爆破
    • newInstance(Object…obj):调用构造器

实例

/**
 * 通过反射创建对象
 */
public class ReflectCreateInstance {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //1. 先获取到User类中的Class对象
        Class<?> userClass = Class.forName("com.xujc.reflection.User");
        //2. 通过pubic的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
        //3. 通过public的有参构造器创建实例
        /*
            constructor 对象就是
            public User(String name) { //public的有参构造器
               this.name = name;
            }
         */

        //3.1 先得到对应的构造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
        //3.2 创建实例,并传入实参
        Object aSoul = constructor.newInstance("一个魂");
        System.out.println("aSoul = " + aSoul);
        //4. 通过非public的有参构造器创建实例
        //4.1 得到private的构造器对象
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
        //4.2 创建实例
        constructor1.setAccessible(true); //暴破【暴力破解】 , 使用反射可以访问private构造器
        Object user2 = constructor1.newInstance(100, "向晚大魔王");
        System.out.println("user2 = " + user2);

    }

}

@Data
@NoArgsConstructor
class User {
    private int age = 10;
    private String name = "嘉然今天吃什么";

    public User(String name) { //public的有参构造器
        this.name = name;
    }

    private User(int age, String name) { //private 有参构造器
        this.age = age;
        this.name = name;
    }
}

7.通过反射访问类中的成员

  • 访问属性

    1. 根据属性名获取Field对象

      Field f = clazz对象.getDeclaredField(属性名);

    2. 爆破

      f.setAccessible(true);

    3. 访问

      f.set(0,值); //o表示对象

      syso(f.get(o)); //o表示对象

    注意: 如果是静态属性，则set和get中的参数o，可以写成null

  • 演示反射操作属性

    /**
 * 演示反射操作属性
 */
public class ReflectAccessProperty {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {

        //1. 得到Student类对应的 Class 对象
        Class<?> stuClass = Class.forName("com.xujc.reflection.Student");
        //2. 创建对象
        Object o = stuClass.newInstance();// o 的运行类型就是Student
        System.out.println(o.getClass()); // Student
        //3. 使用反射得到age 属性对象
        Field age = stuClass.getField("age");
        age.set(o, 88); //通过反射操作属性
        System.out.println(o); //
        System.out.println(age.get(o)); //返回age的值

        //4. 使用反射操作 name 属性
        Field name = stuClass.getDeclaredField("name");
        //对name 进行爆破
        name.setAccessible(true);
        // name.set(o, "乃琳");
        name.set(null,"乃琳");  //因为name是static属性,因此 o 也可以写成null
        System.out.println(o); //获取属性值
        System.out.println(name.get(null)); //获取属性值,要求name是static
    }
}

@Data
@NoArgsConstructor
class Student {
    public int age = 10;
    private static String name = "嘉然今天吃什么";

    public Student(String name) { //public的有参构造器
        this.name = name;
    }

}

  • 访问方法

    1. 根据方法名和参数列表获取Method方法对象:

      Method m = clazz.getDeclaredMethod(方法名, XX.class);//得到本类的所有方法

    2. 获取对象

      Object o = clazz.newInstance();

    3. 爆破

      m.setAccessible(true)

    4. 访问

      Object returnValue = m.invoke(o,实参列表);

    注意: 如果是静态方法,则invoke的参数o,可以写成null

  • 演示反射操作方法

    /**
 * 演示反射操作方法
 */
public class ReflectAccessMethod {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //1. 得到Boss类对应的Class对象
        Class<?> bossCls = Class.forName("com.xujc.reflection.Boss");
        //2. 创建对象
        Object o = bossCls.newInstance();
        //3. 调用public的hi方法
        // Method hi = bossCls.getMethod("hi",String.class);
        //3.1 获得hi方法对象
        Method hi = bossCls.getDeclaredMethod("hi",String.class); //OK
        //3.2 调出
        hi.invoke(o,"world");

        //4. 调用private static方法
        //4.1 得到 say 方法对象
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        //4.2 因为say方法是private,所以需要爆破,原理和前面讲的构造器和属性一样
        say.setAccessible(true);
        System.out.println(say.invoke(o,1,"人",'3'));
        //4.3 因为say方法是static的，还可以这样调用
        System.out.println(say.invoke(null,200,"鬼",'无'));

        //5. 在反射中,如果方法有返回值,统一返回Object,但是他运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 300, "王五", '男');
        System.out.println("reVal的运行类型 = " + reVal.getClass()); // String


    }

}

class Boss {
    private 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);
    }
}
J.T.L
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
反射（Reflect）
weixin_65479202的博客
06-09 526
记录学习反射的基础知识点，超详细，简单易学~~~
反射的用法以及介绍
liaozhixiangjava的博客
06-22 1242
反射（Reflection）是指在程序运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法。反射机制可以使Java程序具有更强的动态性和扩展性，使Java程序更具有灵活性和智能化。Class类：反射的核心类，用于获取类的各种信息，比如类名、构造方法、成员变量、成员方法等。类：用于描述类的构造方法。Method类：用于描述类的成员方法。Field类：用于描述类的成员变量。
反射
cndiafcbsfiuv的博客
01-07 183
反射是指对于任何一个Class类，在"运行的时候"都可以直接得到这个类全部成分。在运行时,可以直接得到这个类的构造器对象：Constructor。在运行时,可以直接得到这个类的成员变量对象：Field。在运行时,可以直接得到这个类的成员方法对象：Method。这种运行时动态获取类信息以及动态调用类中成分的能力称为Java语言的反射机制。
反射（看这一篇就够了！）
esifhuuiwehwe的博客
11-19 268
API文档的官方解释：反射运行对成员变量，成员方法和构造方法的信息进行编程访问简单来说，反射就是从类里把成员变量，构造方法，成员方法挨个拿出来，如下图。
简单介绍反射
fengxia110的博客
02-11 423
反射的相关知识，以及相关类和方法的简单应用
反射（Reflection）
Rooike
03-04 657
反射所对应的包 Class类位于java.lang包下，在java中反射所用到的包位于java.lang.reflect包下： Class类：代表一个类Field类：代表类的属性Method类：代表类的方法Constructor类：代表类的构造方法 反射的步骤 要想使用反射，第一步都需要获得该类或者对象所对应的Class对象。 注意：在java中无论一个类生成了多少个实例
反射Reflection小应用
07-21
在Java编程语言中，反射（Reflection）是一种强大的工具，它允许程序在运行时检查和操作类、接口、字段和方法的信息。通过反射，我们可以动态地创建对象、调用方法、访问字段，甚至处理私有成员，这在某些情况下非常...
C# 反射 Reflection
09-20
2. 命名空间：`System.Reflection`命名空间包含所有与反射相关的类。它是访问类型、成员和元数据的关键入口点。 二、动态类型创建与实例化 1. `Activator.CreateInstance()`: 这个静态方法允许我们在运行时根据类型...
java 反射Reflection；Class类
12-21
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。这一机制使得Java具备了动态性，能够在运行时分析类的结构，调用方法，访问字段，以及创建对象等。以下是关于Java...
reflection反射
07-13
Object instance = constructor.newInstance("Hello, Reflection!"); ``` 这会创建一个带有给定参数的新实例。 ### 5. 调用方法 `Method`对象提供了`invoke(Object obj, Object... args)`方法，允许我们在运行时...
java反射机制Reflection详解
08-26
java反射机制Reflection详解 Java反射机制Reflection是Java语言中的一个重要机制，它允许在程序运行期间访问类、接口、字段和方法，而不必在编译期间知道接口、字段或者方法的名称。反射机制使得Java程序更加灵活和...
Java 反射 -超详细讲解（附源码）
热门推荐
lililuni的博客
10-29 7万+
&amp;amp;amp;amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;amp;amp;amp;nbsp;之前也有学习过反射，可是很快就忘了，也不知道有什么用，怎么用，故特此写下此文，以加深对java反射的理解 1：反射概述 &amp;amp;amp;amp;amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;amp;amp;amp;amp;nbsp;JAVA反射机制是在运行状态中1，对于任意一个类，都
【Java】反射（ reflection）机制 详解
xqs196301的博客
03-01 2685
【Java】反射（ reflection）机制 详解
反射机制（Reflection）
pmc0_0的博客
03-14 131
反射 Reflection(反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 引用加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，反射由此而来 正常方式：引入需要的包类名称—》new实例化—》取得实例化对象 反射方式：实例化对象
28、Java反射（reflection）机制（很重要）
kaoa000的专栏——非淡泊无以明志，非宁静无以致远
01-04 1万+
Java语言的反射机制 在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。 1、Java 反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类。 在运行时构造任意一个类的对象。 在运行时判断任意一
java 反射机制图
biezanhan0147的博客
09-11 119
逐步了解Java反射(Reflect)
Sethereal的博客
11-26 117
一、概念        反射是什么？简单来说就是Java中将类的各个组成部分封装为一种特殊的对象，然后在程序运行过程中其它类都能通过这种特殊对象调用该类的成员方法和成员变量，这就是反射的过程。这也是Java作为动态语言的一个关键特性。 二、运行原理        首先我们需要简单了解一般Java代码在计算机中经历的过程。     
golang 接口
最新发布
m0_70982551的博客
07-24 948
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
掌握Java反射实战：创新与实践指南
《Java Reflection in Action》是一本深入浅出的Java反射指南，作者Ira R. Forman和Nate Forman以其独特的视角，将复杂且有时令人困惑的反射编程技术阐述得清晰易懂。这本书旨在帮助开发者掌握反射这一强大的工具，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

J.T.L

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

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

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

打赏作者

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

抵扣说明：

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

余额充值