注解和反射

于 2022-01-18 19:59:00 发布
阅读量120 收藏
点赞数
分类专栏： 新人3.11 java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Topon1/article/details/122567401
版权

注解和反射

注解(java.Annotation)

  • 注释：给人看的
  • 注解：给程序看也给人看

注解的作用

  • 不是程序本身，可以对程序做出解释
  • 可以被其他程序（例如：编译器等）读取
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yaswGJsQ-1642507130038)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507213155187.png)]

内置注解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2GtamK4W-1642507130039)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507213540822.png)]

元注解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7Vgflp09-1642507130039)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507213721231.png)]

  • 相当于一个约束，例如你创建了一个注解，他就用来约束你用在哪里，例如用在方法里或者类里

  • //定义一个注解
//Target  表示我们的注解可以用在哪些地方，例如用在方法或类中
@Target(value = {ElementType.METHOD,ElementType.TYPE})

//Retention  表示我们的注解在什么地方还有效
@Retention（value = RetentionPolicy.RUNTIME）

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1od1oNtI-1642507130040)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507214643801.png)]

自定义注解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BdeoFnRg-1642507130040)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507214815440.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HjSVgz85-1642507130040)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507215238850.png)]

反射（Java.Reflection）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yn2T15LR-1642507130041)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507215511556.png)]

  • 正常方式：引入需要的“包类”名称—通过new实例化—取得实例对象
  • 反射对象：实例对象—getClass()方法—得到完整的“包类”的名称

反射功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lNSQVwc1-1642507130041)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507220816869.png)]

  • 优点：可以实现动态创建对象和编译，体现出很大的灵活性
  • 缺点：对性能有影响，使用反射是一种解释操作，我们可以告诉jvm，我们希望做什么并且满足我们的要求，这类操作总是慢于 直接执行的操作。
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rV26E8ov-1642507130041)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210511192759614.png)]

得到class类的几种方式

package lianxi;

public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是"+person.name);

        //通过对象获得
        Class c1=person.getClass();
        System.out.println(c1.hashCode());

        //通过forname获得
        Class c2=Class.forName("lianxi.Student");
        System.out.println(c2.hashCode());

        //通过类名.class获得
        Class c3=Student.class;
        System.out.println(c3.hashCode());
        
        //基本内置类型的包装类都有一个Type属性
        //得到的结果返回基本数据类型int
        Class c4 = Integer.TYPE;
        System.out.println(c4.hashCode());
        
        //获得父类类型
        Class c4=c1.getSuperclass();
        System.out.println(c5);
        

    }

}
class Person{
    String name;
    public Person(){

    }
    public Person(String name){
        this.name = name;
    }
    @Override
    public String toString(){
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

}
class Student extends Person{
   public Student(){
       this.name="学生";
   }

}
class Teacher extends Person{
    public Teacher(){
        this.name="老师";
    }
}

哪些类型可以有class对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NPQWzWCi-1642507130042)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507222000794.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eoIk1WbA-1642507130042)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210507222017707.png)]

  • 只要元素类型与纬度一样，就是同一个class

类的加载过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gF9vPjfU-1642507130042)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210509144743790.png)]

  1. 类的加载，类加载器运行
  2. 类的链接，将java类的二进制代码合并到JVM的运行状态之中（1.验证 2.准备 3.解析）
  3. 类的初始化，jvm执行，执行类构造器
  4. 程序初始化时会首先开始类的加载然后创建java.lang.Class对象，然后如果通过main方法new对象，才会生成一个在栈中承接new类的对象。和程序加载时生成的java.lang.Class一样，new出来的类会去找一开始加载生成的class文件
  5. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VbypMhCs-1642507130043)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210509145838045.png)]

什么时候会发生类初始化[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EB3F5eig-1642507130043)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210509150042684.png)]

类的主动引用(一定会发生类的初始化)
  1. 当虚拟机启动先初始化main方法所在的类
  2. new一个类的对象
  3. 使用反射
类的被动引用（不会发生类的初始化）
  1. 子类调用父类的静态方法变量不会不会加载子类
  2. 常量也就是使用final修饰的也不会引起父类跟子类的初始化
类加载器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OS4IJ4Oo-1642507130043)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210509152908430.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iuGwvy4S-1642507130043)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210509152945237.png)]

package lianxi;

public class Test03 {
    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++)
        ClassLoader parent1=parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader=Class.forName("lianxi.Test03").getClassLoader();
        System.out.println(classLoader);

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

        //如何获得系统类加载器可以加载的路劲

        System.out.println(System.getProperty("java.class.path"));

    }
}

获取运行时类的完整结构

  • 通过反射获取运行类时的完整结构
  • feild。method，constructor，superclass，interface，annotation
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2tUajLY7-1642507130044)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210509160855184.png)]
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AdZuYfxd-1642507130044)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210509160922735.png)]
  • 获取public属性用getFields(),找到全部的属性用getDeclaredFields();
  • 获取public方法用getMethods()，获取本类所有方法用getDeclaredMethods();

动态创建对象执行方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1PpCmg6k-1642507130044)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210510232045585.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yhp1nzyT-1642507130044)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210510232030087.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qmBsRCZM-1642507130045)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210510232143543.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-or3bl1m1-1642507130045)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210510232157569.png)]

package lianxi;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Test04 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //获取class对象
        Class c1 = Class.forName("lianxi.User");

       /* //构造一个对象
        User user=(User) c1.newInstance();//本质是调用了类的无参构造
        System.out.println(user);*/

        //通过构造器构造对象，可以不用写无参构造
        Constructor constructor =c1.getDeclaredConstructor(String.class,int.class,int.class);
        User user1 = (User)constructor.newInstance("姚海",001,18);
        System.out.println(user1);
        
        
        //通过反射调用普通方法
        User user2=(User)c1.newInstance();
        //通过反射获取一个方法
        Method setName=c1.getDeclaredMethod("setName", String.class);
           //invoke ： 激活的意思
        //invoke的使用，通过反射获取的方法然后传递对象，在输入方法的值---->>(对象，"方法的值")
        setName.invoke(user2,"孙烨辰");
        System.out.println(user2.getName());
        
        


    }
}

性能对比分析

package lianxi;

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

//分析性能问题
public class Test05 {

    //普通方法调用
    public static void test01(){
        User user =new User();
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 100000000; i++) {
            user.getName();
        }

        long endTime = System.currentTimeMillis();
        System.out.println("普通方法执行10亿次"+(endTime-startTime)+"ms");
    }

    //反射方法调用
    public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user =new User();
        Class c1=user.getClass();

        Method getName = c1.getDeclaredMethod("getName",null);
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 100000000; i++) {
                getName.invoke(user,null);
        }

        long endTime = System.currentTimeMillis();
        System.out.println("反射方法执行10亿次"+(endTime-startTime)+"ms");

    }
    public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user =new User();
        Class c1=user.getClass();

        Method getName = c1.getDeclaredMethod("getName",null);
        getName.setAccessible(true);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 100000000; i++) {
            getName.invoke(user,null);
        }

        long endTime = System.currentTimeMillis();
        System.out.println("关闭检测后反射方法执行10亿次"+(endTime-startTime)+"ms");

    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        test01();
        test02();
        test03();
    }
}

反射操作泛型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7tsazoBZ-1642507130045)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210511001319254.png)]

package lianxi;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

//通过反射获取泛型
public class Test06 {
    public void test01(Map<String,User> map, List<User> list){
        System.out.println("test01");
    }
    public Map<String,User> test02(){
        System.out.println("test02");
        return null;

    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method method =Test06.class.getMethod("test01", Map.class, List.class);

        Type[] genericParameterTypes=method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes){
            System.out.println("#"+genericParameterType);
            if(genericParameterType instanceof ParameterizedType){
                Type[] actualTypeArguments=((ParameterizedType)genericParameterType).getActualTypeArguments();
                for(Type actualTypeArgument:actualTypeArguments){
                    System.out.println(actualTypeArgument);
                }
            }
        }
        method = Test06.class.getMethod("test02",null);
        Type genericReturnType=method.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments=((ParameterizedType)genericReturnType).getActualTypeArguments();
            for(Type actualTypeArgument:actualTypeArguments){
                System.out.println(actualTypeArgument);
            }

    }
}

获取注解信息

ORM

  • 了解什么是ORM?
    • Object relationship Mapping – 》对象关系映射
    • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KzZOcYWS-1642507130046)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210511175156202.png)]
  • java里面的类映射成数据库里的表
package lianxi;

import java.lang.annotation.*;
import java.lang.reflect.Field;

//联系反射操作注解
public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1=Class.forName("lianxi.Student2");

        //通过反射获取注解
        Annotation[] annotations=c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);//结果为    @lianxi.Tableyao(value=db_student)
            
        }
        //获取注解的value的值
        Tableyao tableyao= (Tableyao) c1.getAnnotation(Tableyao.class);
        String value = tableyao.value();
        System.out.println(value);//    结果为db_student

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


    }

}
@Tableyao("db_student")
class Student2{
    @Fieldkuang(columnName = "db_id",type = "int",length = 10)
    private int id;
    @Fieldkuang(columnName = "db_age",type = "int",length = 10)
    private int age;
    @Fieldkuang(columnName = "db_name",type = "varchar",length = 3)
    private String name;


    public Student2() {

    }


    public Student2(int id, int age, String 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 String getName() {
        return name;
    }

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

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

}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldkuang{
    String columnName();
    String type();
    int length();
}
toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

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

}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldkuang{
    String columnName();
    String type();
    int length();
}
Topon1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1177
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java：注解和反射
希望有点用
05-21 2330
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
Java进阶——注解和反射
万里顾一程的博客
03-26 5871
文章目录Java基础——注解和反射1、注解1.1、什么是注解(Annotation)1.2、内置注解1.3、自定义注解和元注解(meta-annotation)2、反射1、反射和反射机制2、CLass类3、哪些类型可以有Class对象4、类加载理解5、类加载器6、通过反射动态的创建对象7、反射操作注解 Java基础——注解和反射 1、注解 1.1、什么是注解(Annotation) 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记， 注解的作
android 注解和反射 (入门以及使用)
高级开发者进阶ing... QaQ
08-16 918
先来看一看今天的效果: 代码效果: 效果不重要,重要的是代码: 注解 官方解释: 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 百度百科 定义一个注解: public @interface SZJ{ } 元注解: 元注解是用来标示当前注解是干什么用的,什么时候用,常用的有2个 @Target E
注解和反射(狂神) 笔记
weixin_43905212的博客
12-14 1344
视频链接 p1 什么是注解：不是程序本身，可以对程序作出解释，但是区别于注释，注解可以写入参数，通过反射机制来获取所注解信息的访问。 p2 元注解：用来注解其他注解，有4个标准的meta-annotation：@Target、@Retention、@Documented、@Inherited，前两个常用。 Target需要传入ElementType数组作为value表示使用范围，其中ElementType是一个枚举类enum，包括类、域、方法、参数等。 Retention表示注解在什么地方有效，SO
Java注解和反射
热门推荐
qq_50806424的博客
08-16 1万+
Java注解和反射 一、反射（Reflection） 在学习反射前我们先了解一下动态语言和静态语言 动态语言和静态语言 动态语言 ​ 在运行中可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他代码结构上的改变，主要的动态语言有JavaScript、Python、PHP、C# 静态语言 ​ 与动态语言相对的，在运行程序过程中代码结构不发生改变的语言叫做静态语言，如C、C++、Java。Java不是动态语言，但Java有一定的动态性，这种动态性我们可以用反
从springboot中的注解再次理解注解和反射
qq_41980102的博客
04-08 1421
从springboot注解再次理解注解和反射 为了看懂源码的注解和反射 1、自述 ​ 在日常的开发中，大家可能已经留意到注解的声影随处可见，特别是在看Springboot源码的时候，自动装配里面运用大量的注解，起初我看源码也是云里雾里的，现在我总结一下我浅薄的见解和理解吧。 2、注解的基础用法 2.1什么是注解？ 对于很多初次接触的开发者来说应该都有这个疑问？ Annontation 是Ja...
注解和反射详解
方圆 Blog
03-24 272
目录一、注解二、元注解三、自定义注解四、反射类的加载过程（了解什么时候会发生类的初始化？类加载器获取类的运行时结构动态创建对象性能问题获取泛型信息反射操作注解（重要 一、注解 注解（Annotation)的作用：可以被其他程序（比如：编译器）读取。 @Override 重写注解 @Deprecated 表示不鼓励使用或者已经废弃，通常是因为它很危险或者存在更好的方法 @SuppressWarni...
利用注解和反射自动生成Sql
ARSLYN的博客
05-15 841
一、注解是什么？ Annotation——注解，是Java中的一种代码辅助工具，其核心作用是用来标注类、方法、变量、参数以及包。我们可以通过反射机制来访问这些标注信息，然后将我们所需要的代码逻辑镶嵌在所标注的元素上，或者改造注解标注的元素来达到我们需要的效果。 这里要做一个区分，注解与注释不同，注释是作者在编辑java代码时对某一段代码或者某一个类、方法等做一个解释。一般用“//这是解释说明内容”、“/*这是解释说明内容/”等方式。注释中的内容是不会被编译进.class文件中的。而注解的内容是可以编译进代码
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java基础之注解和反射
最新发布
08-05
java基础之注解和反射
注解和反射机制的学习笔记
03-05
在Java编程语言中，注解（Annotation）和反射（Reflection）是两个强大的工具，它们极大地扩展了代码的灵活性和动态性。这篇学习笔记将深入探讨这两个主题，帮助开发者更好地理解和运用它们。 首先，我们来了解注解...
java注解和反射的12个demo.zip
04-28
Java注解和反射是Java编程中的重要特性，它们极大地增强了代码的灵活性和可维护性。在Java中，注解（Annotation）是一种元数据，它提供了将信息附加到代码（类、方法、变量等）的方式，而反射则允许我们在运行时检查...
Java使用注解和反射简化编程的方法示例
08-25
例如，在调用大量方法时，可以使用反射和注解简化编程。 下面是一个使用注解和反射简化编程的实例。首先，定义一个注解testAnnoation10： ```java @Documented @Retention(RetentionPolicy.RUNTIME) @Target...
Java中关于注解和反射机制的内容
11-04
Java中关于注解和反射机制的内容
Java基础篇之注解和反射
01-06
Java基础注解和反射入门思维导图 毕竟在SpringBoot以及之后使用的基本全是注解很少用配置文件 反射是必须要会的
JAVA 注解和反射.7z
04-08
总结，Java注解和反射是Java开发中非常重要的技术，它们极大地增强了Java的灵活性和可扩展性。注解简化了代码，提供了元数据，而反射则允许程序在运行时探索和修改自身的结构，两者共同推动了Java的广泛应用。了解并...
注解+ 反射实例demo
11-29
在Java编程语言中，注解（Annotation）和反射（Reflection）是两个强大的特性，它们极大地扩展了代码的可读性和动态性。注解是一种元数据，可以为编译器、工具或运行时系统提供信息，而反射则允许程序在运行时检查类...
如何通过注解和反射获取借接口名
07-16
要通过注解和反射获取接口名，首先需要定义一个注解，并将其应用到接口上。然后使用反射机制来获取接口上的注解信息。 下面是一个示例代码： ```java // 定义一个注解 @Retention(RetentionPolicy.RUNTIME) @...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值