反射

最新推荐文章于 2025-01-29 09:00:00 发布
最新推荐文章于 2025-01-29 09:00:00 发布
阅读量170 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： JavaSE基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_42290922/article/details/81483931

反射概念

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

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类d   方法.所以先要获取到每一个字节码文件对应的Class类型的对象。

总结：反射就是把java类中的各种成分映射成一个个的java对象

例如：一个类有：成员方法，方法，构造方法，包等等信息，利用反射技术可以对一个类进行解剖，把各个组成部分映射成一个个对象。

class类

阅读API的Class类得知，Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

获取Class对象的三种方式

方式一: 通过Object类中的getObject()方法

Person p = new Person();

Class c = p.getClass();

方式二: 通过 类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性,看上去要比第一种方式简单）。

Class c2 = Person.class;

方式三: 通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName即可）。

//Class类的静态方法获取forName（字符串 的类名）包名.类名

Class c3 = Class.forName("Person");

注意：第三种和前两种的区别

前两种你必须明确Person类型.

后面是指定这种类型的字符串就行.这种扩展更强.我不需要知道你的类.我只提供字符串,按照配置文件加载就可以了

        

Person类

package cn.itcast_01_Reflect;

public class Person {

    //成员变量

    public String name;

    public int age;

    private String address;



    //构造方法

    public Person() {

        System.out.println("空参数构造方法");

    }

   

    public Person(String name) {

        this.name = name;

        System.out.println("带有String的构造方法");

    }

    //私有的构造方法

    private Person(String name, int age){

        this.name = name;

        this.age = age;

        System.out.println("带有String，int的构造方法");

    }

   

    public Person(String name, int age, String address){

        this.name = name;

        this.age = age;

        this.address = address;

        System.out.println("带有String, int, String的构造方法");

    }

   

    //成员方法

    //没有返回值没有参数的方法

    public void method1(){

        System.out.println("没有返回值没有参数的方法");

    }

    //没有返回值，有参数的方法

    public void method2(String name){

        System.out.println("没有返回值，有参数的方法 name= "+ name);

    }

    //有返回值，没有参数

    public int method3(){

        System.out.println("有返回值，没有参数的方法");

        return 123;

    }

    //有返回值，有参数的方法

    public String method4(String name){

        System.out.println("有返回值，有参数的方法");

        return "哈哈" + name;

    }

    //私有方法

    private void method5(){

        System.out.println("私有方法");

    }



    @Override

    public String toString() {

        return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";

    }

}

代码演示（获取Class对象的三种方式）

/*

 * 获取.class字节码文件对象的方式

 *      1：通过Object类中的getObject()方法

 *      2: 通过 类名.class 获取到字节码文件对象

 *      3: 反射中的方法,

 *          public static Class<?> forName(String className) throws ClassNotFoundException

 *          返回与带有给定字符串名的类或接口相关联的 Class 对象

 */

public class ReflectDemo {

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

        // 1： 通过Object类中的getObject()方法

        // Person p1 = new Person();

        // Class c1 = p1.getClass();

        // System.out.println("c1 = "+ c1);



        // 2: 通过 类名.class 获取到字节码文件对象

        // Class c2 = Person.class;

        // System.out.println("c2 = "+ c2);



        // 3: 反射中的方法

        Class c3 = Class.forName("cn.itcast_01_Reflect.Person");// 包名.类名

        System.out.println("c3 = " + c3);

    }

}

 

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

在反射机制中，把类中的成员（构造方法、成员方法、成员变量）都封装成了对应的类进行表示。其中，构造方法使用类Constructor表示。可通过Class类中提供的方法获取构造方法：

返回一个构造方法

public Constructor<T> getConstructor(Class<?>... parameterTypes) 获取public修饰, 指定参数类型所对应的构造方法

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取指定参数类型所对应的构造方法(包含私有的)

返回多个构造方法

public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法

public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法(包含私有的)

 

//获取构造方法的代码演示：

public class ReflectDemo {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {

        //获取Class对象

        Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名

       

        //获取所有的构造方法

        //Constructor[] cons = c.getConstructors();

        Constructor[] cons = c.getDeclaredConstructors();

        for (Constructor con : cons) {

            System.out.println(con);

        }

       

        System.out.println("------------------------");

        //获取一个构造方法

        //public Person()

        Constructor con1 = c.getConstructor(null);

        System.out.println(con1);

       

        //public Person(String name)

        Constructor con2 = c.getConstructor(String.class);

        System.out.println(con2);

       

        //private Person(String name, int age)

        Constructor con3 = c.getDeclaredConstructor(String.class, int.class);

        System.out.println(con3);

       

        //public Person(String name, int age, String address)

        Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);

        System.out.println(con4);

    }

}
  1.  

通过反射方式，获取构造方法，创建对象

获取构造方法，步骤如下：

1. 获取到Class对象

2. 获取指定的构造方法

3. 通过构造方法类Constructor中的方法，创建对象

public T newInstance(Object... initargs)

代码演示

public class ConstructorDemo {

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

        //1,获取到Class对象

        Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名

        //2,获取指定的构造方法

        //public Person()

        //Constructor con = c.getConstructor(null);

       

        //public Person(String name, int age, String address)

        Constructor con = c.getConstructor(String.class, int.class, String.class);

       

        //3,通过构造方法类中Constructor的方法，创建对象

        //Object obj = con.newInstance(null);

        Object obj = con.newInstance("小明", 22, "哈尔滨");

       

        //显示

        System.out.println(obj);

    }

}
    1.  

通过反射方式，获取私有构造方法，创建对象

AccessibleObject 类是 Field、Method 和 Constructor 对象的父类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。

对于公共成员、默认（打包）访问成员、受保护成员和私有成员，在分别使用 Field、Method 或 Constructor 对象来设置或获取字段、调用方法，或者创建和初始化类的新实例的时候，会执行访问检查。常用方法如下：

public void setAccessible(boolean flag) throws SecurityException

参数值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。参数值为 false 则指示反射的对象应该实施 Java 语言访问检查。

 

获取私有构造方法，步骤如下：

1. 获取到Class对象

2. 获取指定的构造方法

3. 暴力访问, 通过setAccessible(boolean flag)方法

4. 通过构造方法类Constructor中的方法，创建对象

public T newInstance(Object... initargs)

代码演示：

public class ConstructorDemo2 {

    public static void main(String[] args) throws ClassNotFoundException,

NoSuchMethodException, SecurityException, InstantiationException,

IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        //1,获取到Class对象

        Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.类名

       

        //2,获取指定的构造方法

        //private Person(String name, int age)

        Constructor con = c.getDeclaredConstructor(String.class, int.class);

       

        //3,暴力反射

        con.setAccessible(true);//取消 Java 语言访问检查

       

        //4,通过构造方法类中的功能，创建对象

        Object obj = con.newInstance("小明", 23);

        System.out.println(obj);

       

    }

}
  1.  

通过反射获取成员变量并使用

在反射机制中，把类中的成员变量使用类Field表示。可通过Class类中提供的方法获取成员变量：

返回一个成员变量

public Field getField(String name) 获取指定的 public修饰的变量

public Field getDeclaredField(String name) 获取指定的任意变量

返回多个成员变量

public Field[] getFields() 获取所有public 修饰的变量

public Field[] getDeclaredFields() 获取所有的 变量 (包含私有)

 

获取成员变量的代码演示：

public class FieldDemo {

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

        //获取Class对象

        Class c = Class.forName("cn.itcast_01_Reflect.Person");

       

        //获取成员变量

        //多个变量

        //Field[] fields = c.getFields();

        Field[] fields =  c.getDeclaredFields();

        for (Field field : fields) {

            System.out.println(field);

        }

        System.out.println("-----------------");

        //一个变量

        //public int age;

        Field ageField = c.getField("age");

        System.out.println(ageField);

       

        //private String address

        Field addressField = c.getDeclaredField("address");

        System.out.println(addressField);

    }

}
    1.  

通过反射，创建对象，获取指定的成员变量，进行赋值与获取值操作

获取成员变量，步骤如下：

1. 获取Class对象

2. 获取构造方法

3. 通过构造方法，创建对象

4. 获取指定的成员变量（私有成员变量，通过setAccessible(boolean flag)方法暴力访问）

5. 通过方法，给指定对象的指定成员变量赋值或者获取值

public void set(Object obj, Object value)

在指定对象obj中，将此 Field 对象表示的成员变量设置为指定的新值

public Object get(Object obj)

                     返回指定对象obj中，此 Field 对象表示的成员变量的值

代码演示：

public class FieldDemo2 {

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

        //1,获取Class对象

        Class c = Class.forName("cn.itcast_01_Reflect.Person");

        //2，获取构造方法

        //public Person(String name)

        Constructor con = c.getConstructor(String.class);

        //3，通过构造方法，创建对象

        Object obj = con.newInstance("小明");

        //4，获取指定的成员变量

        //public String name;

        Field nameField = c.getField("name");

        //public int age;

        Field ageField = c.getField("age");

        //private String address;

        Field addressField = c.getDeclaredField("address");

        addressField.setAccessible(true); //取消 Java 语言访问检查

       

        //5，通过方法，给指定对象的指定成员变量赋值或者获取值

        System.out.println("name = "+ nameField.get(obj));

        System.out.println("age = "+ ageField.get(obj));

        System.out.println("address = "+ addressField.get(obj));

       

        //赋值

        ageField.set(obj, 23);

        addressField.set(obj, "凯利广场");

       

        System.out.println("------------------------");

        System.out.println("name = "+ nameField.get(obj));

        System.out.println("age = "+ ageField.get(obj));

        System.out.println("address = "+ addressField.get(obj));

    }

}

通过反射获取成员方法并使用

在反射机制中，把类中的成员方法使用类Method表示。可通过Class类中提供的方法获取成员方法：

返回获取一个方法：

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

                           获取public 修饰的方法

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

                          获取任意的方法，包含私有的

参数1: name 要查找的方法名称； 参数2： parameterTypes 该方法的参数类型

返回获取多个方法：

public Method[] getMethods() 获取本类与父类中所有public 修饰的方法

public Method[] getDeclaredMethods() 获取本类中所有的方法(包含私有的)

获取成员方法的代码演示：

通过反射，创建对象，调用指定的方法

获取成员方法，步骤如下：

1. 获取Class对象

2. 获取构造方法

3. 通过构造方法，创建对象

4. 获取指定的方法

5. 执行找到的方法

public Object invoke(Object obj,  Object... args)

执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。

代码演示：

public class MethodDemo2 {

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

        //1， 获取Class对象

        Class c = Class.forName("cn.itcast_01_Reflect.Person");

        //2,获取构造方法

        //public Person(String name, int age, String address){

        Constructor con = c.getConstructor(String.class, int.class, String.class);

        //3，通过构造方法，创建对象

        Object obj = con.newInstance("小明", 23, "哈尔滨");

        //4，获取指定的方法

        //public void method1()  没有返回值没有参数的方法

        //Method m1 = c.getMethod("method1", null);

       

        //public String method4(String name)

        Method m4 = c.getMethod("method4", String.class);

       

        //5，执行找到的方法

        //m1.invoke(obj, null);

       

        Object result = m4.invoke(obj, "itcast");

        System.out.println("result = " + result);

    }

}

通过反射，创建对象，调用指定的private 方法

获取私有成员方法，步骤如下：

1. 获取Class对象

2. 获取构造方法

3. 通过构造方法，创建对象

4. 获取指定的方法

5. 开启暴力访问

6. 执行找到的方法

public Object invoke(Object obj,  Object... args)

执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。

代码演示：

public class MethodDemo3 {

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

        //1， 获取Class对象

        Class c = Class.forName("cn.itcast_01_Reflect.Person");

        //2,获取构造方法

        //public Person(String name, int age, String address){

        Constructor con = c.getConstructor(String.class, int.class, String.class);

        //3，通过构造方法，创建对象

        Object obj = con.newInstance("小明", 23, "哈尔滨");

        //4，获取指定的方法

        //private void method5(){

        Method m5 = c.getDeclaredMethod("method5", null);

        //5,开启暴力访问

        m5.setAccessible(true);

        //6，执行找到的方法

        m5.invoke(obj, null);

    }

}

  • 泛型擦除

思考，将已存在的ArrayList<Integer>集合中添加一个字符串数据，如何实现呢？

其实程序编译后产生的.class文件中是没有泛型约束的，这种现象我们称为泛型的擦除。那么，我们可以通过反射技术，来完成向有泛型约束的集合中，添加任意类型的元素

 代码如下：

public class ReflectTest {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        ArrayList<Integer> list = new ArrayList<Integer>();

        //添加元素到集合

        list.add(new Integer(30));

        list.add(new Integer("12345"));

        list.add(123);

        //list.add("哈哈");//因为有泛型类型的约束

        System.out.println(list);

       

        //通过反射技术，实现添加任意类型的元素

        //1, 获取字节码文件对象

        //Class c = list.getClass();

        //Class c = ArrayList.class;

        Class c = Class.forName("java.util.ArrayList");

       

        //2, 找到add()方法

        // public boolean add(E e)

        Method addMethod = c.getMethod("add", Object.class);

       

        //3，  执行add()方法

        addMethod.invoke(list, "哈哈");// list.add("哈哈");

        System.out.println(list);

    }

}

  • 反射配置文件

通过反射配置文件，运行配置文件中指定类的对应方法

读取Peoperties.txt文件中的数据，通过反射技术，来完成Person对象的创建

         Peoperties.txt文件内容如下：

className=cn.itcast_01_Reflect.Person

methodName=method5

 

读取配置文件，调用指定类中的对应方法

public class ReflectTest2 {

    public static void main(String[] args)

            throws FileNotFoundException, IOException, ClassNotFoundException, NoSuchMethodException, SecurityException,

            InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

        // 通过Properties集合从文件中读取数据

        Properties prop = new Properties();

        // 读取文件中的数据到集合中

        prop.load(new FileInputStream("properties.txt"));

        // 获取键所对应的值

        String className = prop.getProperty("className");

        System.out.println(className);



        // 1，获取Person.class 字节码文件对象

        Class c = Class.forName(className);

        // 2，获取构造方法

        // public Person(String name, int age, String address)

        Constructor con = c.getConstructor(String.class, int.class, String.class);



        // 3,创建对象

        Object obj = con.newInstance("小明", 20, "中国");

        System.out.println(obj);



        // 4，获取指定的方法

        // private void method5(){}

        String methodName = prop.getProperty("methodName");

        Method m5 = c.getDeclaredMethod(methodName, null);

        // 5,开启暴力访问

        m5.setAccessible(true);

        // 6，执行找到的方法

        m5.invoke(obj, null);

    }

}

 

总结

如何获取.Class文件对象

                   1, 通过Object类 getClass()方法获取 Class对象

                   2, 通过类名.class 方式 获取 Class对象

                   3, 通过反射的方式, Class.forName(String classname) 获取Class对象

                            public static Class<?> forName(String className)throws ClassNotFoundException

返回与带有给定字符串名的类或接口相关联的 Class 对象

 

通过反射， 获取类中的构造方法，并完成对象的创建

                   获取指定的构造方法

                         public Constructor<T> getConstructor(Class<?>... parameterTypes)

                                     获取指定的public修饰的构造方法

                         public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)

                                     获取指定的构造方法，包含私有的

                获取所有的构造方法

                         public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法

                         public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法，包含私有的

 

通过反射， 获取类中的构造方法，并完成对象的创建

                步骤：

                1,获取字节码文件对象

                2,通过字节码文件对象 ，获取到指定的构造方法

                         getConstructor(参数);

                3,通过构造方法，创建对象

                         public T newInstance(Object... initargs)

 

 

私有构造方法，创建对象

                1,获取字节码文件对象

                2,通过字节码文件对象 ，获取到指定的构造方法

                         getDeclaredConstructor (参数);

                3,暴力访问

                         con.setAccessible(true);

                4,通过构造方法，创建对象

                         public T newInstance(Object... initargs)

 

通过反射，获取Class文件中的方法

                获取指定的方法

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

                                   获取指定的public方法

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

                                   获取指定的任意方法，包含私有的

                获取所有的方法

                         public Method[] getMethods() 获取本类与父类中所有public 修饰的方法

                         public Method[] getDeclaredMethods()获取本类中所有的方法，包含私有的

        

通过反射，调用方法

           步骤：

           1，获取Class对象

           2,获取构造方法，创建对象

      3,获取指定的public方法

           4,执行方法     

                    public Object invoke(Object obj, Object... args)

 

私有方法的调用：

          1，获取Class对象

          2,获取构造方法，创建对象

          3,获取指定的private方法

          4,开启暴力访问

                 m5.setAccessible(true);

          5,执行方法   

                 public Object invoke(Object obj, Object... args)

 

通过反射，获取成员变量(字段)

                获取指定的成员变量

                          public Field getField(String name) 获取public修饰的成员变量

                          public Field getDeclaredField(String name) 获取任意的成员变量，包含私有

                获取所有的成员变量

                          public Field[] getFields() 获取所有public修饰的成员变量

                          public Field[] getDeclaredFields() 获取司所有的成员变量，包含私有

 

通过反射，获取成员 变量，并赋值使用

             步骤：

                1,获取字节码文件对象

                2,获取构造方法，创建对象

                3,获取指定的成员变量

                4,对成员变量赋值\获取值操作

                         public void set(Object obj,  Object value) 赋值

                         public Object get(Object obj) 获取值

 

私有成员变量的使用

             步骤：

                1,获取字节码文件对象

                2,获取构造方法，创建对象

                3,获取指定的成员变量

                4,开启暴力访问

                5,对成员变量赋值\获取值操作

                         public void set(Object obj,  Object value) 赋值

                         public Object get(Object obj) 获取值

C#的反射
CoffeMilk的博客
02-22 1万+
一、反射介绍 反射：指程序可以访问、检测和修改它本身状态或行为的一种能力（即：审查元数据并收集关于它的类型信息的能力） ①元数据（编译以后的最基本数据单元）可以理解为一大堆的表，当编译程序集或者模块时，编译器会创建一个类定义表，一个字段定义表，和一个方法定义表等。 ②反射则提供了封装程序集、模块和类型的对象（程序集包含模块，而模块包含类型，类型又包含成员【成员--->类型--->模块--->程序集】）。 ③可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象..
Java 反射
2301_76161469的博客
11-01 7861
反射（reflection）是 Java 中的一项特性，它允许程序在运行时查询和操作类的信息。即，在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意方法和属性。获取到方法和属性后，就可以对其进行修改。这种动态获取信息以及动态调用对象方法的功能也就是Java的反射机制
Java反射技术详解
热门推荐
黄林晴
04-14 24万+
前言 相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习发射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可...
Java基础篇：反射机制详解
张维鹏的博客
12-03 21万+
一、什么是反射： 反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行的时候才动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些...
Java进阶-反射的详解与应用
踏雨歌青春，诗酒趁年华
04-02 4721
本文深入探讨了Java反射机制的核心概念、应用实例及其在现代Java开发中的重要性。文章首先介绍了反射的基本原理和能力，包括在运行时动态获取类信息、操作对象字段和方法的能力。随后，通过具体代码示例，展示了如何利用反射进行字段访问、方法调用、处理泛型方法以及访问私有成员等高级应用，进一步讨论了反射在动态代理、框架开发、数据映射和软件测试中的实用场景。最后，文章总结了反射的优缺点，提出了在实际开发中使用反射的最佳实践和注意事项，为Java开发者提供了一份既全面又深入的反射机制指南。
Java反射（超详细！）
一只小菜鸡
10-02 13万+
1、反射机制有什么用？ 通过java语言中的反射机制可以操作字节码文件（可以读和修改字节码文件。） 通过反射机制可以操作代码片段。（class文件。） 2、反射机制的相关类在哪个包下？ java.lang.reflect.*; 3、反射机制相关的重要的类有哪些？ 类 含义 java.lang.Class 代表整个字节码。代表一个类型，代表整个类。 java.lang.reflect.Method 代表字节码中的方法字节码。代表类中的方法。 java.lang.reflect.Con
反射原理详谈
weixin_45712075的博客
09-03 3625
什么是反射？ 反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。 反射机制的优缺点有哪些？ 优点：能够运行时动态获取类的实例，提高灵活性；可与动态编译结合Class.forName('com.mysql.jdbc.Driver.class');，加载[MySQL](https://www.wkcto.com/courses/mysql.html)的驱动类..
C#高级--反射详解
李宥的博客
08-09 3万+
C#高级–反射详解 一、什么是反射/反编译 1、C#编译运行过程 高级语言->编译->dll/exe文件->CLR/JIT->机器码 2、原理解析 metadata：元数据数据清单，记录了dll中包含了哪些东西,是一个描述。 IL：中间语言，编译把高级语言编译后得到的C#中最真实的语言状态，面向对象语言。 反射：来自于System.Reflection，是一个帮助类库，可以读取dll/exe中metadata，使用metadata创建对象。 Emit：一种反射技术，可以动态创建dl
掌握Java反射：在项目中高效应用反射机制
最新发布
分享即是最好的学习
01-29 2339
Java反射允许程序在运行时动态操作类、方法和字段。本文介绍了反射的原理、应用场景及优缺点，帮助开发者理解如何在实际项目中高效使用反射技术。
UE5中全局照明与反射设置的详细配置：Lumen技术的应用
10-11
在Unreal Engine 5（UE5）中，全局照明和反射的配置主要依赖于Lumen技术。Lumen是一种全新的全动态全局光照和反射系统，它被设计用于次世代主机和高端可视化项目，提供实时的全局照明和反射效果。Lumen作为UE5的默认...
UE5中全局照明和反射的深入配置与优化实践
10-07
在Unreal Engine 5（UE5）中，全局照明和反射是创建真实感场景的关键技术。UE5通过其先进的Lumen全局照明和反射系统，为开发者提供了强大的工具来模拟动态光照和反射效果。本文将详细介绍如何在UE5中配置全局照明和...
matlab模拟光的反射折射.pdf
07-13
在物理学的教学与研究中，光的反射与折射是重要的基础概念。为了帮助学生和研究者更加直观地理解这些光学现象，MATLAB提供了一种强大的工具，可以用来模拟光在不同介质界面的传播行为。本文将围绕如何使用MATLAB模拟...
matlab计算反射阵单元相位(460652)_matlab反射阵相位_matlab反射阵_反射阵matlab_反射阵
09-14
在本文中，我们将深入探讨如何使用MATLAB进行反射阵天线单元相位的计算，这是无线通信和雷达系统中的一个重要概念。MATLAB是一种强大的数学计算软件，尤其适用于数值分析和算法开发，因此它是处理此类问题的理想工具...
computing-reflecting-series.rar_反射波 matlab_反射系数褶积_反射系数设计_合成地震_地震
07-14
本压缩包"computing-reflecting-series.rar"提供了一种使用MATLAB进行反射波模拟和处理的方法，主要涉及以下几个核心知识点： 1. 反射波：在地球内部不同介质的界面，地震波会部分反射，部分透射。这些反射波携带了...
java中栈和堆的区别
没有到不了的明天
07-11 4585
栈(stack)和堆(heap)都是java 用来在RAM中存放数据的地方，与C++不同，java是自动管理栈和堆，程序员不能直接的设置栈和堆。在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。 堆 ...
抽象类和继承总结
没有到不了的明天
08-04 3752
继承：是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有 继承的好处：可继承的属性和方法。                               提高了代表的可维护性                             提高了代码的复用性                             让类与类之间产...
JAVASE 中——字符串输出[Ljava.io.File;@1db9742的问题
没有到不了的明天
07-09 1750
当打印一个字符串数组的时候 例如： File[] files = File.listRoots(); System.out.println(files); 或者下面 String[] Str1 = new String[10]; String[] str1...
javaSE_day01
没有到不了的明天
11-05 880
今日内容介绍 1、Java开发环境搭建 2、HelloWorld案例 3、注释、关键字、标识符 4、数据（数据类型、常量） 01java语言概述 A: java语言概述 a: Java是sun公司开发的一门编程语言,目前被Oracle公司收购，编程语言就是用来编写软件的。 b: Java的应用 开发QQ、迅雷程序(桌面应用软件) 淘宝、京东(互联网应用软件) c: Java的擅长 互...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值