Java基础笔记（泛型）

最新推荐文章于 2024-08-02 10:57:17 发布
最新推荐文章于 2024-08-02 10:57:17 发布
阅读量80 收藏
点赞数
分类专栏： Java SE 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdjgh/article/details/130097246
版权

13 泛型

文章目录

13.1 泛型

  • 基本介绍：
    • 泛型又称参数化类型（接收数据类型的数据类型），是Jdk5.0出现的新特性,解决数据类型的安全性问题
    • 在类声明或实例化时只要指定好需要的具体的类型即可
    • Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
  • 基本语法：
    interface 接口 <T>{}
class 类 <K,V>{}

在类名后指定类型参数的值(类型):
  List<String> strList = new ArrayList<String>();
  lterator<Customer> iterator = customers.iterator();
  • 注意事项和细节：
    1. 泛型只能是引用类型
    2. 在给泛型指定具体类型后，可以传入该类型或者其子类类型
    3. List list3 = new ArrayList()：默认给它的 泛型是[<E＞ E就是 Object]
  • 例：
    public class GenericExercise02 {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<Employee>();
        employees.add(new Employee("jack", 2000, new MyDate(1, 1, 1)));
        employees.add(new Employee("tom", 2000, new MyDate(6, 1, 1)));
        employees.add(new Employee("tom", 3000, new MyDate(3, 1, 1)));
        employees.add(new Employee("jack", 2000, new MyDate(1, 1, 3)));

        employees.sort(new Comparator<Employee>() {//传入匿名内部类接口重写compare方法
            @Override
            public int compare(Employee o1, Employee o2) {
                if (!(o1 instanceof Employee) && (o2 instanceof Employee)) {
                    System.out.println("类型不正确");
                    return 0;
                }
                return o1.getBirthday().compareTo(o2.getBirthday());//在MyDate内重写compareTo方法
            }
        });

        for (Employee employee : employees) {
            System.out.println(employee);
        }
    }
}

class Employee {
    private String name;
    private int sal;
    private MyDate birthday;

    public Employee(String name, int sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public int getSal() {
        return sal;
    }

    public void setSal(int sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}

class MyDate implements Comparable<MyDate> {

    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    @Override
    public int compareTo(MyDate o) {
        int yearMinus = year - o.year;
        if (yearMinus != 0) {
            return yearMinus;
        }
        int monthMinus = month - o.month;
        if (monthMinus != 0) {
            return monthMinus;
        }
        return day - o.day;
    }
}

13.2 自定义泛型

13.2.1泛型类

  • 基本语法：
    class 类名<T,R...>{
  成员;
}
  • 注意事项和细节：

    1. 普通成员可以使用泛型（属性、方法）

    2. 使用泛型的数组，不能初始化

    3. 静态方法中不能使用类的泛型

    4. 泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）

    5. 如果在创建对象时，没有指定类型，默认为Object

      public class CustomGeneric_ {
    public static void main(String[] args) {

        //T=Double, R=String, M=Integer
        Tiger<Double,String,Integer> g = new Tiger<>("john");
        g.setT(10.9); //OK
        //g.setT("yy"); //错误，类型不对
        System.out.println(g);
        Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
        g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
        System.out.println("g2=" + g2);

    }
}

//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型 (属性、方法)
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型
class Tiger<T, R, M> {
    String name;
    R r; //属性使用到泛型
    M m;
    T t;
    //因为数组在new 不能确定T的类型，就无法在内存开空间
    T[] ts;

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

    public Tiger(R r, M m, T t) {//构造器使用泛型

        this.r = r;
        this.m = m;
        this.t = t;
    }

    public Tiger(String name, R r, M m, T t) {//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;
//    public static void m1(M m) {
//
//    }

    //方法使用泛型

    public String getName() {
        return name;
    }

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

    public R getR() {
        return r;
    }

    public void setR(R r) {//方法使用到泛型
        this.r = r;
    }

    public M getM() {//返回类型可以使用泛型.
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

13.2.2泛型接口

  • 基本语法：
    interface 接口名<T,R...>{}
  • 注意事项和细节：

    1. 静态成员不能使用泛型

    2. 泛型接口的类型，在继承接口或者实现接口时确定

    3. 没有指定类型，默认为Object

      public class CustomInterfaceGeneric {
    public static void main(String[] args) {

    }
}

/**
 *  泛型接口使用的说明
 *  1. 接口中，静态成员也不能使用泛型
 *  2. 泛型接口的类型, 在继承接口或者实现接口时确定
 *  3. 没有指定类型，默认为Object
 */

//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {

}
//当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
//，在实现IUsu接口的方法时，使用String替换U, 是Double替换R
class AA implements IA {

    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {

    }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }
}

//实现接口时，直接指定泛型接口的类型
//给U 指定Integer 给 R 指定了 Float
//所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
class BB implements IUsb<Integer, Float> {

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}
//没有指定类型，默认为Object
//建议直接写成 IUsb<Object,Object>
class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {
    }
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }
}

interface IUsb<U, R> {

    int n = 10;
    //U name; 不能这样使用

    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1, R r2, U u1, U u2);

    //在jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

13.2.3泛型方法

  • 基本语法：
    修饰符<T,R...>返回类型 方法名(参数列表){}
  • 注意事项和细节：

    1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中

    2. 当泛型方法被调用时，类型会确定

    3. public void eat(E e) {},
      修饰符后没有<T,R…＞ eat
      方法不是泛型方法，而是使用了泛型

      public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
        System.out.println("=======");
        car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型

        //测试
        //T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}

//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类

    public void run() {//普通方法
    }
    //说明 泛型方法
    //1. <T,R> 就是泛型
    //2. 是提供给 fly使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}

class Fish<T, R> {//泛型类
    public void run() {//普通方法
    }
    public<U,M> void eat(U u, M m) {//泛型方法

    }
    //说明
    //1. 下面hi方法不是泛型方法
    //2. 是hi方法使用了类声明的 泛型
    public void hi(T t) {
    }
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }
}

13.3 泛型继承和通配符

  • 注意事项和细节：

    1. 泛型不具备继承性

    2. <?>：支持任意泛型类型
    3. <? extends A>：支持A类以及A类的子类，规定了泛型的上限
    4. <? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限 
      public class GenericExtends {
    public static void main(String[] args) {

        Object o = new String("xx");

        //泛型没有继承性
        //List<Object> list = new ArrayList<String>();

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是 List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
//        printCollection2(list1);//×
//        printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×


        //冒泡排序

        //插入排序

        //....

    }
    // ? extends AA 表示 上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是Object
            System.out.println(object);
        }
    }


    // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}

class AA {
}

class BB extends AA {
}

class CC extends BB {
}
  • 例：
    public class HomeWork01 {
    public static void main(String[] args) {

    }
    @Test
    public void testList() {
         DAO<User> dao = new DAO<User>();
         dao.save("001",new User(1,10,"jack"));
         dao.save("002",new User(2,11,"tom"));
         dao.save("003",new User(3,12,"mike"));
        List<User> list = dao.list();
        System.out.println(list);

        dao.update("002",new User(2,14,"faker"));
        List<User> list1 = dao.list();
        System.out.println(list1);

        dao.delete("001");
        List<User> list2 = dao.list();
        System.out.println(list2);
    }
}

    public class DAO<T> {//泛型类
    private Map<String, T> map = new HashMap<>();

    public T get(String id) {
        return map.get(id);
    }
    public void update(String id,T entity) {
        map.put(id, entity);
    }
    //返回 map 中存放的所有 T 对象
    //遍历map [k-v],将map的 所有value(T entity),封装到ArrayList返回即可
    public List<T> list() {
        //创建 Arraylist
        List<T> list = new ArrayList<>();

        //遍历map
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            //map.get(key) 返回就是 User对象->ArrayList
            list.add(map.get(key));//也可以直接使用本类的 get(String id)
        }

        return list;
    }
    public void delete(String id) {
        map.remove(id);
    }
    public void save(String id,T entity) {//把entity保存到map
        map.put(id, entity);
    }
}

    public class User {
    private int id;
    private int age;
    private String name;

    public User(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 "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
恐高宇航员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java泛型实例化_java基础-泛型举例详解
weixin_39843215的博客
02-20 1165
泛型泛型是JDK5.0增加的新特性，泛型的本质是参数化类型，即所操作的数据类型被指定为一个参数。这种类型参数可以在类、接口、和方法的创建中，分别被称为泛型类、泛型接口、泛型方法。一、认识泛型在没有泛型之前,通过对类型Object的引用来实现参数的"任意化",但"任意化"带来的缺点是需要显示的强制类型转换,此种转换要求开发者对实际参数类型预知的情况下进行,对于强制转换错误的情况,编译器可能不会提示错...
【Java基础】Java 泛型笔记
lemonfish_1的博客
06-11 188
参考链接泛型，即**“参数化类型”，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法** 如果定义了泛型，编译器就会在编译阶段发现问题，不会出现上述错误泛型只在编译阶段
Java笔记 —— 泛型
一纸春秋的博客
10-14 187
泛型的引入 List集合中是可以加入不同类型的元素的，比如下面这样 public class demo1 { public static void main(String[] args) { List list = new ArrayList(); list.add("hello"); list.add("java"); list.add(12); Iterator iterator = list.iterator()
【Java学习笔记】58 - 泛型
qq_41891655的博客
11-02 230
泛型的介绍 泛型=> E =Integer、String、Dog（表示某种数据类型，表示数据类型的数据类型） 1) 泛型又称参数化类型，是Jdk5.0 出现的新特性,解决数据类型的安全性问题 2) 在类声明或实例化时只要指定好需要的具体的类型即可。 3) Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。 同时，代码更加简洁、健壮 4) 泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的
JAVA笔记—泛型
maohe的博客
08-19 172
泛型知识点
[Java 学习笔记] 泛型
☆迷茫Dog的秘密基地☆
10-17 679
目录 泛型的向上转型 将静态方法的泛型类型和实例类型的泛型类型区分开 多泛型类 java可以创建泛型数组(待完善) Java实现泛型的方法——擦拭法 由此,Java泛型的局限也体现出来 泛型继承(loading) 通配符(loading) 泛型与反射(loading) 总结自廖雪峰老师的Java教程: Java教程 - 廖雪峰的官方网站 (liaoxuefeng.com)https://www.liaoxuefeng.com/wiki/1252599548343744 泛型的...
Java学习笔记：泛型
Z_jl123的博客
02-10 1612
1、泛型 泛型的本质是参数化类型，是将类的类型参数化，具体调用的时候再给具体的类型。这种参数类型可以用在类、方法和接口的创建中，方便称为泛型类、泛型接口和泛型方法。 我们知道JAVA中所有的参数必须提前声明参数类型，例如方法的形参中，如果我们在定义这个方法时不知道这个参数的类型，要等具体调用时才知道，这时我们可以使用泛型来代替那些定义时还不明确的参数类型。 2、定义格式 泛型类：public class 类名 <T> { } 泛型接口：public interface 接口名 <
Java基础笔记之泛型
Python_hfr的博客
03-09 143
Java基础笔记之泛型泛型使用泛型的好处定义含有泛型的类、方法、接口1、定义泛型的类 泛型 泛型是JDK1.5之后出现的新特性，泛指某一种数据类型，当使用一个类、方法、接口不确定要使用什么数据类型的时候，或者说不确定要用来处理哪种数据类型的时候可以定义为泛型。 使用泛型的好处 1.在谈使用泛型的好处之前，先说一下不使用泛型的情况。 例如，在集合创建时，不使用泛型，那么会默认为Object类型，可以储存任意数据类型 public class Demo08Generic { public static
java基础——泛型
上邪的博客
10-11 187
java基础 笔记的都是需要背诵的零散知识点，以顺序的方式组织 文章目录java基础一、泛型二、Junit 一、泛型 1、给泛型指向数据类型是，要求是引用类型，不能是基本数据类型 2、ArrayList arrayList = new ArrayList();泛型默认是 Object 3、自定义泛型类注意事项： （1）语法： class类名<T,R…>{//表示可以有多个泛型成员} （2）普通成员可以使用泛型(属性、方法)2)使用泛型的数组，不能初始化 （3）静态方法中不能使用类的泛
【Java学习笔记】枚举类与泛型
diguangxihua的博客
06-18 992
在Java语言中，使用关键字enum定义一个枚举类型。例：使用枚举类型来指定一周中的天数星期日，星期一，星期二，星期三，星期四，星期五，星期六在任何时候，如果需要代表一系列固定的常量，就应该使用枚举类型。在两种情况下，尽可能使用枚举类型：一种是自然的枚举类型，例如，表示太阳系中的行星或者员工的性别，这是一组 固定的值，所以在程序中应该使用枚举类型来表示；另一种是程序在编译的时候，已经知道某个数据所有可能的值，也要尽可能的使用枚举类型。例如，在扑克牌游戏中,花色是固定的。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 590
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
Karen198的博客
07-31 506
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 547
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
JavaSE面向对象进阶
qq_45348840的博客
07-30 469
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 348
1.导入hutool的maven依赖。2.直接复制一下代码运行。
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 964
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java并发（十一）一文搞懂Java并发各种容器
m0_58466443的博客
07-29 845
同步容器将所有对容器状态的访问都串行化，以保证线程安全性，这种策略会严重降低并发性。Java 1.5 后提供了多种并发容器，使用并发容器来替代同步容器，可以极大地提高伸缩性并降低风险。并发容器对应的普通容器描述HashMapJava 1.8 之前采用分段锁机制细化锁粒度，降低阻塞，从而提高并发性；Java 1.8 之后基于 CAS 实现。SortedMap基于跳表实现的ArrayListSet基于实现。SortedSet基于实现。Queue线程安全的无界队列。底层采用单链表。支持 FIFO。
java中static关键字的作用
weixin_41020960的博客
08-01 505
这意味着这个变量被类的所有实例共享，而不是每个实例拥有自己的副本。类变量可以通过类名直接访问，而不需要创建类的实例。关键字是 Java 中一个非常重要的特性，它允许开发者在不创建对象的情况下访问类的方法和变量，这在很多场景下非常有用。这类方法可以在没有创建类的实例的情况下被调用，它们只能访问类的静态变量和静态方法。关键字也可以用于静态初始化块，这是一段在类加载时执行的代码块，用于初始化静态变量。: 静态变量是不变的，一旦在静态初始化块或静态方法中被初始化，它们的值就不能被修改。关键字可以声明静态内部类。
spring原理（自学第六天）
最新发布
GD2604279407的博客
08-02 393
今天将会学到Aware 接口及 InitializingBean 接口我们可以先了解他们的作用：1. Aware 接口用于注入一些与容器相关信息, 例如a. BeanNameAware 注入 bean 的名字b. BeanFactoryAware 注入 BeanFactory 容器c. ApplicationContextAware 注入 ApplicationContext 容器2. InitializingBean 接口提供了一种【内置】的初始化手段。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

恐高宇航员

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

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

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

打赏作者

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

抵扣说明：

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

余额充值