反射

最新推荐文章于 2025-12-22 15:57:21 发布
转载 最新推荐文章于 2025-12-22 15:57:21 发布 · 126 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://blog.youkuaiyun.com/weixin_46572109/article/details/111410568
文章标签：

#反射 #java

文章目录

反射（Reflection）

类加载后，在堆内存中的方法区中间产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，称之为：反射

反射机制允许程序在运行期间获取任何类的内部信息（比如类名，类的接口，类的方法，字段，属性…），并且能够直接操作任意对象的内部属性及方法。

反射提供的功能

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法
  • 在运行时处理注解
  • 生成动态代理
  • …

反射的优缺点

优点：

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

缺点：

对性能有影响，使用反射基本上是一种解释操作，我们可以告诉JVM 我们希望做什么并且它满足我们的需求。这类操作总是慢于 直接执行相同的操作。

1.Class类

在这里插入图片描述

通过对象反射出类的名称就是反射
在这里插入图片描述

Class类的常用方法

在这里插入图片描述

获得Class类的方式

a）如果已有具体的类，通过类的class属性获取，最为安 全可靠且性能最高的方法。

Class 变量=XXX.class;

b）已知某个类的实例，调用此实例的getClass()方法获取Class对象。

Class 变量=XXX.getClass();

c）已知一个类的全名且在类路径下，可以通过Class类的静态方法forName()获取，需要处理异常ClassNotFoundException

Class 变量=Class.forName("类的全限定名");

d）内置基本数据类型可以直接使用类名.Type

e）还可以用ClassLoader（之后讲解）

测试：

public class TestClass {
	
	public static void main(String[] args) throws ClassNotFoundException {
		
		Student student=new Student();
		
		//a.
		Class class1=Student.class;
		
		//b.
		Class class2=student.getClass();
		
		//c.
		Class class3=Class.forName("com.kuang.reflect.Student");
		
		//d.
		Class class4=Integer.TYPE;
		
		//获得父类Class
		Class class5=class1.getSuperclass();
		
		System.out.println(class1.hashCode());
		System.out.println(class2.hashCode());
		System.out.println(class3.hashCode());
		System.out.println(class4);
		System.out.println(class5);
		
	}	
}

class Person{}

class Student extends Person{}

在这里插入图片描述
哪些类型可以有Class对象？

  • class:外部类、成员（成员内部类、静态内部类），局 - 部内部类，匿名内部类。
  • interface：接口
  • []：数组
  • enum：枚举
  • annotation：注解 （也是一个类型）
  • primitive type：基本数据类型
  • void

测试：

public class Test {
	
	public static void main(String[] args) {
		
		Class class1=Object.class;//类
		Class class2=Serializable.class;//接口
		Class class3=String[].class;//一维数组
		Class class4=int[][].class;//二维数组
		Class class5=Override.class;//注解
		Class class6=ElementType.class;//枚举
		Class class7=double.class;//基本数据类型
		Class class8=void.class;//void （代表空类型）
		Class class9=Class.class;//Class
		
		System.out.println(class1);
		System.out.println(class2);
		System.out.println(class3);
		System.out.println(class4);
		System.out.println(class5);
		System.out.println(class6);
		System.out.println(class7);
		System.out.println(class8);
		System.out.println(class9);
	}
	
}

在这里插入图片描述

2.类加载内存分析

java内存分析

在这里插入图片描述
类的加载过程
在这里插入图片描述
在这里插入图片描述
测试：

public class Test05 {
    public static void main(String[] args) {
        A a =new A();
        System.out.println(A.m);

        /**
         * 1.加载到内存，会产生一个对应Class对象
         * 2.链接， 链接结束后 m=0
         * 3.初始化
                <clint>(){
                        System.out.println("A类静态代码块初始化");
                        m=300;
                        m=100;
                 }
         */
    }
}

class A{

    //无参构造方法
    public A(){
        System.out.println("A类的无参构造初始化");

    }
    //静态代码块
    static {
        System.out.println("A类静态代码块初始化");
        m=300;
    }

    /**
     * m=300
     * m=100  （覆盖了上面的值）
     */
    //静态变量
    static int m=100;
}

在这里插入图片描述

1.加载阶段，将编译好的class文件加载到内存中（方法区）
2.然后会生成一个代表这个类的Class对象
3.链接阶段，会为静态变量分配内存并设置默认值
4.开始执行main方法，实例化一个A对象放在堆内存中，然后去找自己的Class类（图上4有误），拿到所有属性，方法等
5.初始化阶段，赋值
在这里插入图片描述
分析类的初始化
在这里插入图片描述
1.主动引用

public class Test06 {

    static {
        System.out.println("Main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        // Son son=new Son();

        //反射也会产生主动引用
        Class.forName("com.javacto.reflection.Son");
    }
}
class Father{
    static int b=2;

    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");

    }
    static  int m=100;
    static final int M =1;  //常量
}

在这里插入图片描述
2.被动引用

public class Test06 {


    static {
        System.out.println("Main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {


        //System.out.println("==========不会发生类的初始化===============");
        //不会产生类的引用的方法
        //1.通过子类引用父类的静态变量，不会导致子类初始化  因为static在链接阶段的时候已经存在了
        //System.out.println(Father.b);  

        //2.只是一个数组 命了一个名和开辟了空间而已
        //Son [] array= new Son[5];
		//System.out.println(array.getClass());
		
        //3.常量不会引起父类与子类的初始化，因为所有的常量以及静态变量，都是在链接阶段都已经赋了一个值了，初始化的时候已经存在了
        //System.out.println(Son.M);  


    }
}
class Father{
    static int b=2;

    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");

    }
    static  int m=100;
    static final int M =1;  //常量
}

在这里插入图片描述

3.类加载器

在这里插入图片描述
在这里插入图片描述
java平台核心库：rt.jar 包

扩展类加载器 ：ExtClassLoader:

系统类加载器： System Classloder ，也有的地方叫 AppClassLoader

java的运行环境jre -> lib 目录 运行所有的jar包都在这里面

测试获取加载器：

public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统的类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器："+systemClassLoader);

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

        //获取扩展类加载器的父类加载器--> 根加载器 （c/c++ 写的 读取不到 返回 null）
        ClassLoader parent1 = parent.getParent();
        System.out.println("根加载器："+parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("com.javacto.reflection.Test07").getClassLoader();
        System.out.println("当前类加载器："+classLoader);

        //测试jdk 内置的类是谁加载的
        classLoader=Class.forName("java.lang.Object").getClassLoader();
        System.out.println("JDK内置类的加载器："+classLoader);  //根加载器加载的

    }
}

可以看到 jdk内置类的加载器 就是java平台核心库，跟加载器加载的 因为用c++编写的的，无法直接获取 所有显示null。

了解什么是双亲委派机制：

如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己才想办法去完成。

优点：避免重复加载 + 避免核心类篡改

采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次。其次是考虑到安全因素，java核心api中定义类型不会被随意替换，假设通过网络传递一个名为java.lang.Integer的类，通过双亲委托模式传递到启动类加载器，而启动类加载器在核心Java API发现这个名字的类，发现该类已被加载，并不会重新加载网络传递的过来的java.lang.Integer，而直接返回已加载过的Integer.class，这样便可以防止核心API库被随意篡改。

4.获取运行时类的完整结构

Field（字段）、Method（方法）、Constructor（构造器）、Superclass（父类）、Interface（接口）、Annotation（注解）

//获得类的信息
public class Test08 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.javacto.reflection.User");

        System.out.println("=========获得类的名字=============");
        //类的名字
        System.out.println(c1.getName());//包名+类名
        System.out.println(c1.getSimpleName());//类名

        /*
        打印输出结果
        com.javacto.reflection.User
        User
         */

        System.out.println("==============获得类的属性===================");
        //获得类的属性
        Field[] field1=c1.getFields();//只能找到public属性
        for (Field f :field1) {
            System.out.println(f);  //因为没有定义public属性所以为无
        }

        Field[] field2=c1.getDeclaredFields();//找到全部的属性
        for (Field f :field2) {
            System.out.println(f);
        }

        /*
        输出结果
        private java.lang.String com.javacto.reflection.User.name
        private int com.javacto.reflection.User.id
        private int com.javacto.reflection.User.age
         */

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

        /*
        输出结果
        指定：private java.lang.String com.javacto.reflection.User.name
         */

        //获得类的方法
        System.out.println("==============获得类的方法===================");
        Method[] methods=c1.getMethods();//获得本类及其父类的全部public方法
        for (Method method:methods) {
            System.out.println("正常的："+method);
        }
        methods=c1.getDeclaredMethods();//获得本类的所有方法，包括私有的  不包括父类
        for (Method method:methods) {
            System.out.println("DeclaredMethods："+method);
        }

        /*
        打印输出结果
        正常的：public java.lang.String com.javacto.reflection.User.toString()
        正常的：public java.lang.String com.javacto.reflection.User.getName()
        正常的：public int com.javacto.reflection.User.getId()
        正常的：public void com.javacto.reflection.User.setName(java.lang.String)
        正常的：public int com.javacto.reflection.User.getAge()
        正常的：public void com.javacto.reflection.User.setId(int)
        正常的：public void com.javacto.reflection.User.setAge(int)
        正常的：public final void java.lang.Object.wait() throws java.lang.InterruptedException
        正常的：public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
        正常的：public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
        正常的：public boolean java.lang.Object.equals(java.lang.Object)
        正常的：public native int java.lang.Object.hashCode()
        正常的：public final native java.lang.Class java.lang.Object.getClass()
        正常的：public final native void java.lang.Object.notify()
        正常的：public final native void java.lang.Object.notifyAll()
        DeclaredMethods：public java.lang.String com.javacto.reflection.User.toString()
        DeclaredMethods：public java.lang.String com.javacto.reflection.User.getName()
        DeclaredMethods：public int com.javacto.reflection.User.getId()
        DeclaredMethods：public void com.javacto.reflection.User.setName(java.lang.String)
        DeclaredMethods：private void com.javacto.reflection.User.test()
        DeclaredMethods：public int com.javacto.reflection.User.getAge()
        DeclaredMethods：public void com.javacto.reflection.User.setId(int)
        DeclaredMethods：public void com.javacto.reflection.User.setAge(int)
         */

        //获得指定方法只需要在（）中添加参数（方法名，方法参数）
        //添加参数  实则是因为考虑到了 重载
        System.out.println("============获得指定方法=============");
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);

        System.out.println(getName);
        System.out.println(setName);

        /*
        打印输出结果
        public java.lang.String com.javacto.reflection.User.getName()
        public void com.javacto.reflection.User.setName(java.lang.String)
         */


        System.out.println("=============获得指定的构造器===================");
        //获得指定构造器
        Constructor[] constructors=c1.getConstructors();//获得public方法

        for (Constructor constructor : constructors) {
            System.out.println("public："+constructor);
        }
        constructors=c1.getDeclaredConstructors();//获得本类所有方法
        for (Constructor c :constructors) {
            System.out.println("全部："+c);
        }
        //获得指定构造器  (String name, int id, int age)
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定构造器："+declaredConstructor);
        
        /*
        打印输出结果：
        public：public com.javacto.reflection.User(java.lang.String,int,int)
        public：public com.javacto.reflection.User()
        全部：public com.javacto.reflection.User(java.lang.String,int,int)
        全部：public com.javacto.reflection.User()
        指定构造器：public com.javacto.reflection.User(java.lang.String,int,int)
         */
    }
}

5.通过反射动态创建对象测试

public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c1 = Class.forName("com.javacto.reflection.User");

        //构造一个对象
       /* User user = (User)c1.newInstance(); //本质上调用了类的无参构造器
        System.out.println(user);  //User{name='null', id=0, age=0}*/

        //通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);

        User user2 = (User) constructor.newInstance("小明", 1, 18);
        System.out.println(user2); //User{name='小明', id=1, age=18}


        //通过反射调用普通方法
        User user3= (User) c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getMethod("setName", String.class);

        //invoke: 激活的意思  (对象， "方法需要的参数")
        setName.invoke(user3,"小明3");
        System.out.println(user3.getName());


        System.out.println("========通过反射操作属性===========");
        //通过反射操作属性
        User user4= (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        
        //不能直接操作私有属性， 我们需要关闭程序的安全检查，属性或者方法的 setAccessible(true)
        name.setAccessible(true);
        name.set(user4,"小明4"); //修改属性值
        System.out.println(user4.getName());//setAccessible 默认为false 如果没有关闭将会报没有访问private的权限
        //can not access a member of class com.javacto.reflection.User with modifiers "private"

    }
}

invoke(对象，"参数")：激活方法
setAccessible：关闭安全检查

6.获取泛型信息

Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换的问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除。

思考该怎么获得? (之前有说过，类加载的时候就产生了Class对象，故class对象里面应该是有保留的)

public class Test11 {

    /**
     * 通过泛型传参
     * @param map
     * @param list
     */
    public void test01(Map<String,User> map, List <User> list){
        System.out.println("test01");

    }



    /**
     * 通过泛型返回值
     * @return
     */
    public Map<String,User> test02(){
        System.out.println("test02");
        return null;
    }


    public static void main(String[] args) throws NoSuchMethodException {
        //获得参数类型
        Method method = Test11.class.getMethod("test01", Map.class, List.class);
        //获取参数类型  即Map和 List
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("1:"+genericParameterType);

            //判断genericParameterType参数类型 是否属于 ParameterizedType 参数化类型
            if (genericParameterType instanceof ParameterizedType){
                //如果属于参数化类型，获得他的真实类型 getActualTypeArguments
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();

                //再次输出真实的泛型信息
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println("2:"+actualTypeArgument);
                }
            }
        }
        
        
        //获得返回值类型
        method = Test11.class.getMethod("test02",null);
        Type genericReturnType = method.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType){
            //如果genericReturnType返回值类型属于参数化类型，获得他的真实类型 getActualTypeArguments
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            
            //再次输出真实的泛型信息
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println("3:"+actualTypeArgument);
            }
        }
    }
}

7.获取注解信息

在这里插入图片描述

public class Test12 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.javacto.reflection.Student2");

        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解的value的值   获取指定注解值
        MyTable myTable =(MyTable) c1.getAnnotation(MyTable.class);
        String value = myTable.value();
        System.out.println(value);


        //获得类指定的注解
        System.out.println("=====获得类指定的注解======");
        Field f= c1.getDeclaredField("name");
        MyField annotation = f.getAnnotation(MyField.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }

}

@MyTable("db_students")
class Student2{
    @MyField(columnName = "db_id",type = "int",length = 10)
    private int id;
    @MyField(columnName = "db_age",type = "int",length = 10)
    private int age;
    @MyField(columnName = "db_name",type = "varchar",length = 50)
    private System name;

    public Student2() {
    }

    public Student2(int id, int age, System name) {
        this.id = id;
        this.age = age;
        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;
    }

    public System getName() {
        return name;
    }

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

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

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface MyTable{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyField{
    String columnName(); //列名
    String type(); //类型
    int length(); //长度
}
C#的反射
CoffeMilk的博客
02-22 1万+
一、反射介绍 反射：指程序可以访问、检测和修改它本身状态或行为的一种能力（即：审查元数据并收集关于它的类型信息的能力） ①元数据（编译以后的最基本数据单元）可以理解为一大堆的表，当编译程序集或者模块时，编译器会创建一个类定义表，一个字段定义表，和一个方法定义表等。 ②反射则提供了封装程序集、模块和类型的对象（程序集包含模块，而模块包含类型，类型又包含成员【成员--->类型--->模块--->程序集】）。 ③可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象..
UE5中全局照明和反射的深入配置与优化实践
10-07
在Unreal Engine 5（UE5）中，全局照明和反射是创建真实感场景的关键技术。UE5通过其先进的Lumen全局照明和反射系统，为开发者提供了强大的工具来模拟动态光照和反射效果。本文将详细介绍如何在UE5中配置全局照明和...
Java 反射
2301_76161469的博客
11-01 8325
反射（reflection）是 Java 中的一项特性，它允许程序在运行时查询和操作类的信息。即，在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意方法和属性。获取到方法和属性后，就可以对其进行修改。这种动态获取信息以及动态调用对象方法的功能也就是Java的反射机制
Java反射技术详解
热门推荐
黄林晴
04-14 24万+
前言 相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习发射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可...
Java基础篇：反射机制详解
张维鹏的博客
12-03 22万+
一、什么是反射： 反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行的时候才动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些...
Java进阶-反射的详解与应用
踏雨歌青春，诗酒趁年华
04-02 4920
本文深入探讨了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 3678
什么是反射？ 反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。 反射机制的优缺点有哪些？ 优点：能够运行时动态获取类的实例，提高灵活性；可与动态编译结合Class.forName('com.mysql.jdbc.Driver.class');，加载[MySQL](https://www.wkcto.com/courses/mysql.html)的驱动类..
掌握Java反射：在项目中高效应用反射机制
分享即是最好的学习
01-29 2450
Java反射允许程序在运行时动态操作类、方法和字段。本文介绍了反射的原理、应用场景及优缺点，帮助开发者理解如何在实际项目中高效使用反射技术。
C#进阶-反射的详解与应用
踏雨歌青春，诗酒趁年华
03-27 5864
本文作为C#进阶阶段的学习内容详细介绍了C#中反射的应用，提供了一个反射在C#中应用的概览，通过一系列的说明、代码示例和应用场景介绍，深入探讨了反射（Reflection）这一C#中的高级特性，展示其概念、应用场景以及具体的代码示例。希望本文能够帮助读者更好地理解和运用C#中这一强大的特性。
精选资源
fdtd-matlab.rar_FDTD 反射_FDTD反射谱_matlab 多层膜_反射透射_透射反射
09-19
标题中的“fdtd-matlab.rar”表明这是一个与FDTD（Finite-Difference Time-Domain）方法相关的MATLAB项目，主要用于模拟光在多层膜结构中的反射和透射现象。FDTD是一种广泛应用于电磁场计算的数值模拟技术，特别是在...
精选资源
UE5中全局照明与反射设置的详细配置：Lumen技术的应用
10-11
在Unreal Engine 5（UE5）中，全局照明和反射的配置主要依赖于Lumen技术。Lumen是一种全新的全动态全局光照和反射系统，它被设计用于次世代主机和高端可视化项目，提供实时的全局照明和反射效果。Lumen作为UE5的默认...
matlab计算反射阵单元相位(460652)_matlab反射阵相位_matlab反射阵_反射阵matlab_反射阵
09-14
在本文中，我们将深入探讨如何使用MATLAB进行反射阵天线单元相位的计算，这是无线通信和雷达系统中的一个重要概念。MATLAB是一种强大的数学计算软件，尤其适用于数值分析和算法开发，因此它是处理此类问题的理想工具...
精选资源
computing-reflecting-series.rar_反射波 matlab_反射系数褶积_反射系数设计_合成地震_地震
07-14
本压缩包"computing-reflecting-series.rar"提供了一种使用MATLAB进行反射波模拟和处理的方法，主要涉及以下几个核心知识点： 1. 反射波：在地球内部不同介质的界面，地震波会部分反射，部分透射。这些反射波携带了...
Java ArrayList和线性表
最新发布
Harrybili的博客
12-22 623
在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下说明是以泛型方式实现的，使用时必须要先实例化实现了接口，表明ArrayList支持随机访问实现了Cloneable接口，表明ArrayList是可以clone的实现了接口，表明ArrayList是支持序列化的5.和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList。
JAVA设计模式之观察者模式
pingguocu3的博客
12-17 397
在我们开发的过程中，经常会遇到一些当什么什么事情发生的时候，然后做什么什么事。比如某种商品的物价上涨时会导致部分商家高兴，而消费者伤心。平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。著作权归作者所有,转载或内容合作请联系作者。
MyBatis-Plus 单元测试中 Lambda Mock 的坑与解决
qq_43657722的博客
12-17 1248
本文总结了 MyBatis-Plus 在单元测试中使用 LambdaWrapper 时常见的 Lambda 缓存异常问题，分析其根源在于 Mock 环境缺失真实上下文。通过精简示例说明为何 any(LambdaWrapper.class) 易出错，并给出使用 any() 的稳定解决方案，强调单元测试应聚焦业务逻辑、避免过度关注 SQL 与 Lambda 细节。
Windows安装Maven
heqilai1的博客
12-17 250
Maven是一个基于POM模型的项目管理和构建自动化工具，其核心是通过一份配置文件，实现依赖管理和标准化的构建流程。对于Java开发者而言，Maven不是一个可选项，而是一个基础设施。它极大地降低了项目管理的复杂度，让开发者可以更专注于编写代码，而不是浪费时间在“搭建环境”和“寻找Jar包”上，Maven因其稳定、成熟和广泛的应用，至今仍是Java生态系统中最主流的构建工具。二、下载Maven https://maven.apache.org/download.cgi。至此Maven安装配置完成 😊😊。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值