Java-反射【简析】

最新推荐文章于 2024-06-04 23:11:16 发布
最新推荐文章于 2024-06-04 23:11:16 发布
阅读量78 收藏
点赞数
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qxl217/article/details/132288326
版权

目录

什么是反射：

在Java中，反射是一种机制，可以在运行时获取和操作类的信息，包括类的字段、方法、构造函数等。它允许程序在运行时动态地调用类的方法或访问类的属性，而不需要提前编写固定的代码。

通过反射，你可以在运行时通过类的全限定名获取对应的Class对象，并通过该Class对象获取类的信息和执行相应的操作。

  1. 动态地创建对象：通过Class对象的实例化方法，你可以在运行时动态地创建类的实例。

  2. 动态地调用方法：通过Method类，你可以在运行时动态地调用类的方法，包括私有方法。

  3. 动态地获取和设置属性：通过Field类，你可以在运行时动态地获取和设置类的属性值，包括私有属性。

  4. 动态地操作构造函数：通过Constructor类，你可以在运行时动态地创建类的实例。

反射机制有什么用：

  1. 动态加载类：反射机制允许在运行时动态加载类，即使在编译时并不知道要使用哪个类。这对于实现插件化系统、动态扩展和模块化开发非常有用。

  2. 运行时获取类的信息：通过反射，可以获得类的结构信息，包括字段、方法、构造函数、注解等。这使得我们可以在运行时自省类的特性，从而做一些灵活的操作，比如动态生成文档、序列化/反序列化、动态代理等。

  3. 动态创建对象和执行方法：使用反射，可以在运行时动态创建对象和调用方法。这对于一些通用工具和框架非常有用，可以根据外部条件或配置来实例化对象和执行方法。

  4. 修改私有属性和方法的访问权限：反射机制可以突破访问权限限制，获取和修改类的私有属性和方法。虽然这种操作必须谨慎使用，但在一些特殊场景下，如测试和调试，可能会有一定的用处。

  5. 与注解结合使用：反射机制与注解相结合可以实现一些强大的功能，如自定义注解处理器、注解驱动的开发等。通过反射可以获取并解析类、方法、字段上的注解信息，并根据注解信息做相应的处理。

总的来说，反射机制在很多场景下都能提供灵活性和扩展性，但也需要注意反射运行时开销高、易出错等问题，因此在使用反射时需要权衡利弊，并选择适当的应用场景。

Java反射机制的优点：

  • 动态性和灵活性：反射机制允许在运行时动态地加载类、获取类信息、创建对象和执行方法。这使得程序能够根据需要在运行时做出决策，实现灵活的逻辑和动态的行为。

  • 扩展性：通过反射，可以在不修改源代码的情况下，对类进行扩展和定制。你可以使用反射来添加新的功能、修改现有功能或实现一些通用的操作，而不需要改变原始类的结构。

  • 提高代码的可重用性和可维护性：反射机制使得代码可以更加通用和灵活。你可以编写一些通用的代码，通过反射来处理不同的类和对象。这样可以减少重复代码的编写，并提高代码的可重用性和可维护性。

  • 框架和工具开发：反射机制为框架和工具提供了强大的支持。很多框架和工具，如Spring、Hibernate等，都广泛使用了反射机制来实现自动配置、对象映射等功能。反射使得这些框架和工具能够更加灵活和可扩展。

  • 探索和调试：反射机制可以帮助你探索和调试类的结构和行为。你可以使用反射来获取类的详细信息，查看类的方法、字段和注解等。这对于调试和检查代码非常有用，尤其在开发复杂的系统时。

反射机制相关的重要的类有哪些？

  1. Class类：
    java.lang.Class类代表一个类或接口，在运行时可以使用Class类获取类的信息和进行操作。通过Class类，可以获取类的字段、方法、构造函数、注解等信息，还可以实例化对象、执行方法等操作。
  • 获取Class对象：
方法备注
getClass()获取当前对象的Class对象。
.class直接使用类字面量来获取Class对象。
Class.forName(String className)根据类的全限定名加载对应的Class对象。
  • 获取类的信息：
方法备注
getName()获取类的全限定名。
getPackage()获取类所在的包。
getModifiers()获取类的修饰符。
getSuperclass()获取类的父类。
getInterfaces()获取类实现的接口列表。
  • 创建对象：
方法备注
newInstance()通过无参构造函数创建类的实例。
getConstructor(Class<?>… parameterTypes)获取指定参数类型的公共构造函数。
getDeclaredConstructor(Class<?>… parameterTypes)获取指定参数类型的所有构造函数（包括私有）。
  • 访问和操作类的成员：
方法备注
getField(String name)获取指定名称的公共字段。
getDeclaredField(String name)获取指定名称的字段（包括私有）。
getMethod(String name, Class<?>… parameterTypes)获取指定名称和参数类型的公共方法。
getDeclaredMethod(String name, Class<?>… parameterTypes)获取指定名称和参数类型的方法（包括私有）。
  • 执行方法：
方法备注
invoke(Object obj, Object… args)调用指定对象上的方法，并传递相应的参数。
setAccessible(true)设置私有成员的可访问性，以便访问和操作私有成员。
  1. Field类：
    java.lang.reflect.Field类代表类的成员变量（字段）。通过Field类，可以获取和设置类的字段的值，还可以获取字段的类型和修饰符等信息。
  • 获取字段信息：
方法备注
getName()获取字段的名称。
getType()获取字段的类型。
getModifiers()获取字段的修饰符。
getDeclaringClass()获取声明该字段的类的Class对象。
  • 获取和修改字段的值：
方法备注
get(Object obj)获取指定对象上该字段的值。
set(Object obj, Object value)给指定对象的该字段赋值。
  • 修改字段的可访问性：
方法备注
setAccessible(true)设置字段的可访问性，以便访问和操作私有字段。

下面是一个简单的示例代码，演示了如何使用Field类来获取和修改类的字段：

import java.lang.reflect.Field;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 获取Person类的Class对象
            Class<?> personClass = Class.forName("com.example.Person");

            // 获取Person类的name字段
            Field nameField = personClass.getDeclaredField("name");

            // 创建一个Person对象
            Object person = personClass.newInstance();

            // 设置字段的可访问性（如果是私有字段）
            nameField.setAccessible(true);

            // 给name字段赋值
            nameField.set(person, "John Doe");

            // 获取name字段的值
            Object nameValue = nameField.get(person);

            // 输出结果
            System.out.println(nameValue); // 输出：John Doe
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. Method类：
    java.lang.reflect.Method类代表类的方法。通过Method类，可以调用类的方法，并传递相应的参数。还可以获取方法的返回类型、参数类型、修饰符等信息。
  • 获取方法信息：
方法备注
getName()获取方法的名称。
getReturnType()获取方法的返回类型。
getParameterTypes()获取方法的参数类型列表。
getModifiers()获取方法的修饰符。
getDeclaringClass()获取声明该方法的类的Class对象。
  • 调用方法：
方法备注
invoke(Object obj, Object… args)调用指定对象上的方法，并传递相应的参数。
  • 修改方法的可访问性：
方法备注
setAccessible(true)设置方法的可访问性，以便访问和调用私有方法。

下面是一个简单的示例代码，演示了如何使用Method类来获取和调用类的方法：

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 获取Math类的Class对象
            Class<?> mathClass = Class.forName("java.lang.Math");

            // 获取Math类的random方法
            Method randomMethod = mathClass.getMethod("random");

            // 调用random方法
            Object result = randomMethod.invoke(null);

            // 输出结果
            System.out.println(result); // 输出：随机数值
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. Constructor类：
    java.lang.reflect.Constructor类代表类的构造函数。通过Constructor类，可以实例化对象，并传递相应的参数。还可以获取构造函数的参数类型和修饰符等信息。
  • 获取构造函数信息：
方法备注
etName()获取构造函数的名称。
getParameterTypes()获取构造函数的参数类型列表。
getModifiers()获取构造函数的修饰符。
getDeclaringClass()获取声明该构造函数的类的Class对象。
  • 实例化对象：
方法备注
newInstance(Object… args)使用指定参数实例化对象。
  • 修改构造函数的可访问性：
方法备注
setAccessible(true)设置构造函数的可访问性，以便实例化对象。

下面是一个简单的示例代码，演示了如何使用Constructor类来获取和实例化类的对象：

import java.lang.reflect.Constructor;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 获取Person类的Class对象
            Class<?> personClass = Class.forName("com.example.Person");

            // 获取Person类的有参构造函数
            Constructor<?> constructor = personClass.getConstructor(String.class, int.class);

            // 使用构造函数实例化对象
            Object person = constructor.newInstance("John Doe", 25);

            // 输出结果
            System.out.println(person); // 输出：Person{name='John Doe', age=25}
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. Modifier类：
    java.lang.reflect.Modifier类用于操作和查看访问修饰符的信息。它提供了一些静态方法，可以判断字段、方法和类的修饰符。
  • 解析修饰符：
方法备注
isPublic(int modifiers)判断修饰符是否为public。
isPrivate(int modifiers)判断修饰符是否为private。
isProtected(int modifiers)判断修饰符是否为protected。
isStatic(int modifiers)判断修饰符是否为static。
isFinal(int modifiers)判断修饰符是否为final。
isAbstract(int modifiers)判断修饰符是否为abstract。
isNative(int modifiers)判断修饰符是否为native。
isSynchronized(int modifiers)判断修饰符是否为synchronized。
isVolatile(int modifiers)判断修饰符是否为volatile。
isTransient(int modifiers)判断修饰符是否为transient。
isStrict(int modifiers)判断修饰符是否为strictfp。
  • 操作修饰符：
方法备注
toString(int modifiers)将修饰符转换为字符串表示。
addModifiers(int baseModifiers, int additionalModifier)添加修饰符。
removeModifiers(int baseModifiers, int removedModifier)移除修饰符。

下面是一个简单的示例代码，演示了如何使用Modifier类来解析和操作修饰符：

import java.lang.reflect.Modifier;

public class ModifierExample {
    public static void main(String[] args) {
        // 示例修饰符
        int modifiers = Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL;

        // 解析修饰符
        boolean isPublic = Modifier.isPublic(modifiers);
        boolean isStatic = Modifier.isStatic(modifiers);
        boolean isFinal = Modifier.isFinal(modifiers);

        // 输出结果
        System.out.println("Public: " + isPublic); // 输出：true
        System.out.println("Static: " + isStatic); // 输出：true
        System.out.println("Final: " + isFinal); // 输出：true

        // 添加修饰符
        int newModifiers = Modifier.addModifiers(modifiers, Modifier.SYNCHRONIZED);

        // 移除修饰符
        int removedModifiers = Modifier.removeModifiers(newModifiers, Modifier.STATIC);

        // 输出结果
        System.out.println("New Modifiers: " + Modifier.toString(newModifiers)); // 输出：public static final synchronized
        System.out.println("Removed Modifiers: " + Modifier.toString(removedModifiers)); // 输出：public final synchronized
    }
}
  1. Proxy类：
    java.lang.reflect.Proxy类用于创建动态代理对象。通过Proxy类，可以创建一个实现指定接口的代理类对象，可以在代理对象上执行一些自定义的逻辑。
  • 创建代理类：
方法备注
newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)创建实现指定接口的代理类实例。
  • InvocationHandler接口：
方法备注
invoke(Object proxy, Method method, Object[] args)代理类的方法调用处理。在该方法中，可以通过反射执行代理类的方法，并添加额外的逻辑或行为。

使用Proxy类创建代理类的基本步骤如下：
1.创建一个实现InvocationHandler接口的类，重写invoke()方法，定义代理类方法的处理逻辑。
2.使用Proxy的静态方法newProxyInstance()创建代理类的实例。

下面是一个简单的示例代码，演示了如何使用Proxy类创建代理类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义接口
interface Hello {
    void sayHello();
}

// 实现InvocationHandler接口
class HelloInvocationHandler implements InvocationHandler {
    private final Hello target;

    public HelloInvocationHandler(Hello target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method is invoked");
        Object result = method.invoke(target, args);
        System.out.println("After method is invoked");
        return result;
    }
}

public class ProxyExample {
    public static void main(String[] args) {
        // 创建目标对象
        Hello hello = new Hello() {
            @Override
            public void sayHello() {
                System.out.println("Hello, World!");
            }
        };

        // 创建代理对象
        HelloInvocationHandler handler = new HelloInvocationHandler(hello);
        Hello proxyHello = (Hello) Proxy.newProxyInstance(
                hello.getClass().getClassLoader(),
                hello.getClass().getInterfaces(),
                handler
        );

        // 调用代理对象的方法
        proxyHello.sayHello();
    }
}

获取Class的三种方式

  1. 使用.getClass()方法：对于已经存在的对象，可以通过调用对象的getClass()方法来获取对应的Class对象。例如：
String str = "Hello";
Class<?> cls = str.getClass();
  1. 使用.class字面量：对于已知的类名，可以使用类名后跟上.class来获取对应的Class对象。例如：
Class<?> cls = String.class;
  1. 使用Class.forName()方法：对于类名存在于字符串中的情况，可以使用Class类的静态方法forName()来获取对应的Class对象。例如：
String className = "java.lang.String";
Class<?> cls = Class.forName(className);

需要注意的是，使用Class.forName()方法时需要提供完整的类名（包括包名），并且需要处理ClassNotFoundException异常。另外，这种方式还适用于加载外部的、未知的类。

反射实例化

  1. 获取对应类的Class对象：通过上述提到的三种方式之一，获取到表示对应类的Class对象。

  2. 获取构造函数：使用Class对象的getConstructor()或getDeclaredConstructor()方法来获取构造函数对象。getConstructor() 方法用于获取公共的构造函数，而 getDeclaredConstructor() 方法可以获取所有类型的构造函数，包括私有的构造函数。需要根据需要选择合适的方法。

  3. 创建实例：通过构造函数对象的 newInstance() 方法来创建类的实例。newInstance() 方法会调用构造函数并返回一个新创建的对象。

下面是一个简单的例子，演示了如何使用反射来实例化一个类：

import java.lang.reflect.Constructor;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 获取String类的Class对象
            Class<?> stringClass = Class.forName("java.lang.String");

            // 获取String类的无参构造函数对象
            Constructor<?> constructor = stringClass.getConstructor();

            // 使用构造函数对象创建String类的实例
            String strInstance = (String) constructor.newInstance();

            System.out.println(strInstance); // 输出：空字符串
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

需要注意的是，实例化对象时需要处理各种可能的异常，比如类未找到异常、构造函数未找到异常等。此外，私有构造函数需要调用 setAccessible(true) 方法设置为可访问，才能成功实例化私有类。

反射动态方法调用

使用反射机制可以动态地调用类的方法，包括公共方法和私有方法。

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 获取String类的Class对象
            Class<?> stringClass = Class.forName("java.lang.String");

            // 获取String类的toUpperCase方法
            Method toUpperCaseMethod = stringClass.getMethod("toUpperCase");

            // 创建一个String对象
            String str = "hello world";

            // 调用toUpperCase方法
            Object result = toUpperCaseMethod.invoke(str);

            // 输出结果
            System.out.println(result); // 输出：HELLO WORLD
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

需要注意的是，在调用方法时，需要处理各种可能的异常，比如类未找到异常、方法未找到异常、非法访问异常等。还需注意参数和返回值的类型要匹配，否则会引发类型转换异常。

反射的应用

  1. 动态加载类和对象实例化：在运行时通过类名加载类，并实例化对象。这种场景下，可以使用Class类的forName()方法和newInstance()方法来实现。

  2. 获取类的信息：通过反射机制可以获取类的名称、字段、方法、构造函数、父类、接口等信息。这种场景下，可以使用Class类提供的各种方法来获取相应的信息。

  3. 调用对象的方法：通过反射机制可以在运行时动态调用对象的方法，传递参数，并获取返回值。这种场景下，可以使用Method类的invoke()方法来实现。

  4. 修改对象的属性：通过反射机制可以在运行时修改对象的字段值，包括私有字段。这种场景下，可以使用Field类的set()方法来实现。

  5. 动态代理和AOP：通过反射机制可以在运行时生成代理类，实现动态代理和AOP（面向切面编程）。这种场景下，可以使用Proxy类和InvocationHandler接口来实现。

  6. 解析注解：通过反射机制可以获取类、字段、方法上的注解，并解析注解中的元数据信息。这种场景下，可以使用Class类、Field类、Method类等来获取注解信息。

  7. 序列化和反序列化：通过反射机制可以在运行时动态地将对象转换为字节流进行序列化，以及将字节流反序列化为对象。这种场景下，可以使用ObjectInputStream和ObjectOutputStream类操作字节流，辅以反射机制进行对象的序列化和反序列化。

  8. Java Bean的操作：通过反射机制可以对Java Bean对象进行操作，比如动态设置和获取字段值、调用getter和setter方法，以及动态触发事件等。

Java反射机制的应用场景涵盖了各个领域，包括动态加载、反射调用、代理和AOP、注解处理、序列化和反序列化等。它能够提供灵活性和扩展性，让开发人员在运行时动态地操作和控制代码的行为。

qxl217
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
GB50150-2016简析
02-11
GB50150-2016简析 电气装置安装工程电气设备交接试验标准
Java中的泛型简析实战.zip
11-04
Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战...
Java-API简析_java.net.Socket类（基于 Latest JDK）（浅析源码）
进步*于辰的博客
07-08 1万+
本篇文章是我解析Java-API的笔记，更多的是从方法着手，少对类的整体情况进行说明，故并不详尽，可供大家参考。 如果文中阐述不全或不对的，多多交流。
Java-API简析_java.lang.SecurityManager类（基于 Latest JDK）（浅析源码）
进步*于辰的博客
06-23 1万+
本篇文章是我解析Java-API的笔记，更多的是从方法着手，少对类的整体情况进行说明，故并不详尽，可供大家参考。 如果文中阐述不全或不对的，多多交流。
Java-API简析_java.lang.ClassLoader类（基于 Latest JDK）（浅析源码）
进步*于辰的博客
06-23 1万+
本篇文章是我解析Java-API的笔记，更多的是从方法着手，少对类的整体情况进行说明，故并不详尽，可供大家参考。 如果文中阐述不全或不对的，多多交流。
Java-API简析_java.lang.reflect.Proxy类（基于 Latest JDK）（浅析源码）
进步*于辰的博客
06-24 1万+
本篇文章是我解析Java-API的笔记，更多的是从方法着手，少对类的整体情况进行说明，故并不详尽，可供大家参考。 如果文中阐述不全或不对的，多多交流。
Java-API简析_java.lang.Class＜T＞类（基于 Latest JDK）（浅析源码）
进步*于辰的博客
05-24 1万+
本篇文章是我解析Java-API的笔记，更多的是从方法着手，少对类的整体情况进行说明，故并不详尽，可供大家参考。 如果文中阐述不全或不对的，多多交流。
Java-API简析_java.lang.reflect.Field类（基于 Latest JDK）（浅析源码）
热门推荐
进步*于辰的博客
07-22 1万+
本篇文章是我解析Java-API的笔记，更多的是从方法着手，少对类的整体情况进行说明，故并不详尽，可供大家参考。 如果文中阐述不全或不对的，多多交流。
Java反射原理简析
天高任鸟飞，海阔凭鱼跃
04-30 1010
Java的反射机制允许我们动态的调用某个对象的方法/构造函数，获取某个对象的属性等，而无需在编码时确定调用的对象。这种机制在我们常用的框架中也非常常见。 1.原理简介 类actionClass = Class.forName（“ MyClass”）; 对象action = actionClass.newInstance（）; 方法method = actionClass.getMethod（“ m...
java反射最佳实践_Java 反射简析
weixin_42510407的博客
03-08 94
一直以来，多少Java编程人员对于Java的反射讳莫如深，其实简单粗暴的说，所谓反射就是文件与Java对象之间的转换而已。我们编写的Java后缀的文件，经过编译之后就成为class后缀的文件了，jvm对其进行登记。反射的时候，jvm按照花名册，加载所有相关的class文件。这时候，文件里面就是代码，就是对象。加载之后呢，按照Java规则，将其还原为我们熟悉的Java文件，这时候这个class文件就...
简析Java的反射机制
qq_42770493的博客
02-25 124
Java的反射机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。 一.Class类 在程序运行期间，Java运行时系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类。保存这些信息的类被称为Class。当我们使用Object类中的getClass方法我们将会得到一个...
Python反射用法实例简析
09-20
主要介绍了Python反射用法,结合实例形式简单分析了Python反射的概念、原理及使用方法,需要的朋友可以参考下
教师公招--判断简析(教育心理学).doc
10-12
教师公招--判断简析(教育心理学).doc
zebra-vtysh简析
09-16
简要介绍了zebra-vtysh的架构以及相关的命令实现
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1625
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
java环境部署
JiuMeilove的博客
06-04 389
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
java中Overload和Override的区别
codedadi的博客
06-04 574
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
最新发布
星途码客的博客
06-04 1431
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
java break和return的区别_简析Java中return和break的区别
06-02
在Java中，`break`和`return`都是控制程序流程的关键字，但它们的作用和使用场景是不同的。 `break`用于跳出循环，可以用于`switch`语句中的`case`分支和循环语句中的`for`、`while`、`do-while`等循环结构中。当...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值