JavaSE——泛型

news2024/11/23 6:18:45

目录

一、泛型的引入

二、泛型的好处

三、泛型介绍

四、泛型的语法

(一)泛型的声明

(二)泛型的实例化

五、泛型使用的注意事项和细节

六、泛型练习题1

七、自定义泛型

(一)自定义泛型类

(二)自定义泛型接口

(三)自定义泛型方法

八、泛型练习题2

九、泛型的继承和通配符

一、泛型的引入

使用传统的集合添加数据的时候，有以下几点弊端：

  1. 不能对加入到集合ArrayList中的数据类型进行约束(不安全)
  2. 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

二、泛型的好处

1.编译时，检查添加元素的类型，提高了安全性

2.减少了类型转换的次数，提高效率

  • 不使用泛型

Dog-加入->Object-取出->Dog        放入到ArrayList中会先转成Object，在取出时，还需要转换成Dog

  • 使用泛型

Dog->Dog->Dog        放入和取出时，不需要类型转换，提高效率

3.不再提示编译警告 

public class Generic01 {
    public static void main(String[] args) {
        // 做一个泛型约束
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("aa", 1));
        arrayList.add(new Dog("bb", 2));
        arrayList.add(new Dog("cc", 3));

        // 使用泛型遍历，不需要向下转型
        for (Dog dog : arrayList) {
            System.out.println(dog);
        }
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

三、泛型介绍

泛型是一种表示数据类型的数据类型。

  1. 泛型又称参数化类型，是JDK5出现的新特性，解决数据类型的安全性问题
  2. 在类声明或实例化时只要指定好需要的具体的类型即可
  3. Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
  4. 泛型的作业是：可以在类声明时通过一个标识，表示类中某个属性的类型，或者是方法的返回值的类型，或者是参数类型。
  5. 注意，特别强调： E具体的数据类型，在定义Person对象的时候指定，即在编译期间，就确定E是什么类型。
public class Generic03 {
    public static void main(String[] args) {
        Person<String> person = new Person<String>("韩顺平教育");
        person.show(); //String

        /*
            可以这样理解：上面的Person类
            class Person {
                String s ;// E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型

                public Person(String s) {//E也可以是参数类型
                    this.s = s;
                }

                public String f() {//返回类型使用E
                    return s;
                }
            }
         */

        Person<Integer> person2 = new Person<Integer>(100);
        person2.show();//Integer

        /*
            class Person {
                Integer s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型

                public Person(Integer s) {//E也可以是参数类型
                    this.s = s;
                }

                public Integer f() {//返回类型使用E
                    return s;
                }
            }
         */
    }
}

// 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
class Person<E> {
    E s; // E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型

    public Person(E s) { // E也可以是参数类型
        this.s = s;
    }

    public E f() {//返回类型使用E
        return s;
    }

    public void show() {
        System.out.println(s.getClass()); // 显示s的运行类型
    }
}

四、泛型的语法

(一)泛型的声明

interface接口<T>{} 和 class类<K,V>{}        比如：List，ArrayList

说明：1)其中，T、K、V不代表值，而是表示类型

           2)任意字母都可以。常用T表示，是Type的缩写

(二)泛型的实例化

要在类名后面指定类型参数的值(类型)。如：

List<String> strList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();

        创建3个学生对象，放入到HashSet中使用，放入到HashMap中使用，要求Key是 String name，Value 就是学生对象，使用两种方式遍历。

代码实现：

@SuppressWarnings({"all"})
public class GenericExercise {
    public static void main(String[] args) {
        // 使用泛型方式给HashSet 放入3个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 28));
        students.add(new Student("mary", 19));

        // 增强for遍历
        for (Student student : students) {
            System.out.println(student);
        }
        
        System.out.println("--------------------------");
        // 使用泛型方式给HashMap 放入3个学生对象
        // K -> String V->Student
        HashMap<String, Student> hm = new HashMap<String, Student>();
        /*
            public class HashMap<K,V>  {}
         */
        hm.put("milan", new Student("milan", 38));
        hm.put("smith", new Student("smith", 48));
        hm.put("tom", new Student("tom", 28));

        // 迭代器遍历
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next = iterator.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }
    }
}

class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

五、泛型使用的注意事项和细节

  1. 泛型类型只能是引用数据类型，不可以设置基本数据类型 
    List<Integer> list = new ArrayList<Integer>(); //OK
// List<int> list2 = new ArrayList<int>();//错误
  2. 在指定泛型具体类型后，可以传入该类型或其子类类型 
    Pig<A> aPig = new Pig<A>(new A());
aPig.f();
// class com.testdemo.generic.A

Pig<A> aPig2 = new Pig<A>(new B());
aPig2.f();
// class com.testdemo.generic.B


class A {}
class B extends A {}

class Pig<E> {
    E e;
    public Pig(E e) {
        this.e = e;
    }
    public void f() {
        System.out.println(e.getClass()); // 运行类型
    }
}
  3. 泛型使用形式可以简化 
    ArrayList<Integer> list3 = new ArrayList<>();
List<Integer> list4 = new ArrayList<>();
ArrayList<Pig> pigs = new ArrayList<>();

  4. 不写泛型默认是 Object类型

    ArrayList arrayList = new ArrayList();
// 等价于 ArrayList<Object> arrayList = new ArrayList<Object>();

六、泛型练习题1

代码实现：

MyDate类：

public class MyDate implements Comparable<MyDate> {
    private int year;
    private int month;
    private int day;

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", 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;
    }

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

    /**
     * 比较brithday
     * @param o the object to be compared.
     * @return
     */
    @Override
    public int compareTo(MyDate o) {
        // 比较生日
        int yearMinus = year - o.getYear();
        if (yearMinus != 0) {
            return yearMinus;
        }
        int monthMinus = month - o.getMonth();
        if (monthMinus != 0) {
            return monthMinus;
        }
        return day - o.getDay();
    }
}

Employee类：

public class Employee {
    private String name;
    private double sal;
    private MyDate birthday;

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

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

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

    public MyDate getBirthday() {
        return birthday;
    }

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

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

测试类：

public class GenericExercise02 {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        Employee aa = new Employee("aa", 8000, new MyDate(1980, 2, 4));
        Employee bb = new Employee("张三", 9000, new MyDate(1999, 12, 24));
        Employee ccc = new Employee("张三", 5500, new MyDate(1999, 12, 18));

        employees.add(aa);
        employees.add(bb);
        employees.add(ccc);
        System.out.println("----------排序后：----------");
        for (Employee employee : employees) {
            System.out.println(employee);
        }

        // 排序
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                if (!(o1 instanceof Employee && o2 instanceof Employee)) {
                    System.out.println("类型不正确...");
                    return 0;
                }
                // 比较name
                int i = o1.getName().length() - o2.getName().length();
                if (i != 0) {
                    return i;
                }
                return o1.getBirthday().compareTo(o2.getBirthday());
            }
        });
        System.out.println("----------排序后：----------");
        for (Employee employee : employees) {
            System.out.println(employee);
        }
    }
}

运行结果：

七、自定义泛型

(一)自定义泛型类

基本语法：

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{name='john', r=null, m=null, t=10.9, ts=null}

        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);
        // g2=Tiger{name='john~~', r=null, m=null, t=yy, ts=null}
    }
}

// 1. Tiger 后面定义泛型，所以Tiger 就称为自定义泛型类
// 2. T, R, M 泛型的标识符, 一般是单个大写字母
// 3. 泛型标识符可以有多个
class Tiger<T, R, M> {
    String name;
    R r; // 属性使用到泛型
    M m;
    T t;
    // 因为数组在new 不能确定T的类型，就无法在内存开空间，不能new泛型数组
    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) +
                '}';
    }
}

(二)自定义泛型接口

基本语法：

interface 接口名<T,R...>{
}

注意细节：

  1. 接口中，静态成员也不能使用泛型(和泛型类规定相同)
  2. 泛型接口的类型，在继承接口或实现接口时确定
  3. 没有指定类型，默认为Object 

代码示例：

public class CustomInterfaceGeneric {
    public static void main(String[] args) {
    }
}
// 在继承接口 指定泛型接口的类型
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;
    }
}

(三)自定义泛型方法

基本语法：

修饰符 <T,R...> 返回类型 方法名(参数列表){
}

注意细节：

  1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中
  2. 当泛型方法被调用时，类型会确定
  3. 修饰符后没有泛型，那么该方法就不是泛型方法，而是使用了泛型

代码示例：

public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);// 当调用方法时，传入参数，编译器，就会确定类型
        // class java.lang.String
        // class java.lang.Integer
        System.out.println("=======");
        car.fly(300, 100.1);// 当调用方法时，传入参数，编译器，就会确定类型
        // class java.lang.Integer
        // class java.lang.Double
        
        // 测试
        // T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
        // class java.util.ArrayList
        // class java.lang.Float
    }
}

// 泛型方法，可以定义在普通类中, 也可以定义在泛型类中
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
    }
}

八、泛型练习题2

public class CustomMethodGenericExercise {
    public static void main(String[] args) {
        // T->String, R->Integer, M->Double
        Apple<String, Integer, Double> apple = new Apple<>();
        apple.fly(10); // 10 会被自动装箱 Integer10, 输出Integer
        apple.fly(new Dog()); // Dog
    }
}

class Apple<T, R, M> { // 自定义泛型类
    public <E> void fly(E e) {  // 泛型方法
        System.out.println(e.getClass().getSimpleName()); // 只显示类名：Integer
    }

    // public void eat(U u) {} // 错误，因为U没有声明
    public void run(M m) {} // ok
}
class Dog {}

九、泛型的继承和通配符

  1. 泛型不具备继承性 
    // List<Object> list = new ArrayList<String>(); // 错误写法，编译报错
  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 {}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2216639.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Linux-进程间通信】vscode使用通信引入匿名管道引入

【Linux-进程间通信】vscode使用通信引入匿名管道引入

一、新系统&#xff0c;新软件 1.新系统 哈喽宝子们&#xff0c;从今以后我们不再使用风靡一时的CentOS系统了&#xff0c;因为CentOS已经不在维护了&#xff0c;各大公司几乎也都从CentOS转入其他操作系统了&#xff1b;我们现在由原来的CentOS系统切换到最新的Ubuntu系统&a…
阅读更多...
向日葵下载教程以及三款远程控制工具推荐！！！

向日葵下载教程以及三款远程控制工具推荐！！！

向日葵远程控制下载教程&#xff01;&#xff01; 亲爱的朋友们&#xff0c;如果你对远程控制软件有所需求&#xff0c;那么向日葵绝对是一个不错的选择。现在我将带你走一遍向日葵的下载流程。 1. 打开你的浏览器&#xff0c;输入“向日葵官方网站”&#xff0c;进入官方网站…
阅读更多...
力扣之1398.购买了产品A和产品B却没有购买产品C顾客

力扣之1398.购买了产品A和产品B却没有购买产品C顾客

题目&#xff1a; Sql 建表语句&#xff1a; Create table If Not Exists Customers (customer_id int, customer_name varchar(30)) Create table If Not Exists Orders (order_id int, customer_id int, product_name varchar(30)) Truncate table Customers insert in…
阅读更多...
前端求职简历-待补充

前端求职简历-待补充

当然可以&#xff0c;针对大厂的前端岗位&#xff0c;一个吸引人的简历应该突出你的技术能力、项目经验、教育背景以及任何能体现你学习能力和团队协作能力的证明。以下是一个简历大纲示例&#xff0c;你可以根据自己的实际情况进行调整&#xff1a; 个人信息 姓名联系方式&a…
阅读更多...
如何在算家云搭建SadTalker（数字人）

如何在算家云搭建SadTalker（数字人）

一、SadTalker简介 SadTalker 是一个基于深度学习的AI 数字人制作工具&#xff0c;可以通过对照片中的人物进行动态化处理,生成具有头部运动和面部表情的数字人。该模型通过接收一张图片和一段音频文件&#xff0c;能够自动生成包含人脸动作&#xff08;如张嘴、眨眼、移动头部…
阅读更多...
comfyui工作流保姆级教程来啦（附整合包）！从入门到精通一文解决

comfyui工作流保姆级教程来啦（附整合包）！从入门到精通一文解决

一、SD主流 UI Stable Diffusion&#xff08;SD&#xff09;因为其开源特性&#xff0c;有着较高的受欢迎程度&#xff0c;并且基于SD的开源社区及教程、插件等&#xff0c;都是所有工具里最多的。基于SD&#xff0c;有不同的操作界面&#xff0c;可以理解为一个工具的不同客户…
阅读更多...
网络编程（21）——通过beast库快速实现http服务器

网络编程（21）——通过beast库快速实现http服务器

目录 二十一、day21 1. 头文件和作用域重命名 2. reponse时调用的一些函数 3. http_connection a. 构造函数 b. start() c. process_request() d. create_response() e. create_post_response() f. write_response() 4. Server 5. 主函数 6. 测试 1&#xff09;测…
阅读更多...
AOP 面向切面编程

AOP 面向切面编程

1.准备工作&#xff0c;创建maven项目 1. pom.xml 加入依赖 <dependencies><!--spring核心坐标--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.6</version&…
阅读更多...
【Python入门】提升 Python 水平的高级指南

【Python入门】提升 Python 水平的高级指南

如果你正在学习Python&#xff0c;那么你需要的话可以&#xff0c;点击这里&#x1f449;Python重磅福利&#xff1a;入门&进阶全套学习资料、电子书、软件包、项目源码等等免费分享&#xff01; Python是一种功能强大且灵活的编程语言&#xff0c;深受开发者喜爱。尽管Py…
阅读更多...
番外篇 | 史上最全的关于CV的一些经典注意力机制代码汇总

番外篇 | 史上最全的关于CV的一些经典注意力机制代码汇总

前言：Hello大家好，我是小哥谈。注意力是人类认知系统的核心部分，它允许我们在各种感官输入中筛选和专注于特定信息。这一能力帮助我们处理海量的信息，关注重要的事物，而不会被次要的事物淹没。受到人类认知系统的启发，计算机科学家开发了注意力机制，这种机制模仿人类的这…
阅读更多...
H5 Canvas 举牌小人

H5 Canvas 举牌小人

之前看到这种的举牌小人的图片觉得很有意思&#xff0c;最近有时间所以就尝试写写看。 在线链接 https://linyisonger.github.io/H5.Examples/?name./080.Canvas%20%E4%B8%BE%E7%89%8C%E5%B0%8F%E4%BA%BA.html 生成效果 实现代码 <!DOCTYPE html> <html lang"…
阅读更多...
Spring Boot在医疗信息交互系统中的应用

Spring Boot在医疗信息交互系统中的应用

第1章绪论 计算机已经从科研院所&#xff0c;大中型企业&#xff0c;走进了平常百姓家&#xff0c;Internet遍及世界各地&#xff0c;在网上能够用计算机进行文字草拟、修改、打印清样、文件登陆、检索、综合统计、分类、数据库管理等&#xff0c;用科学的方法将无序的信息进行…
阅读更多...
运行第一个Java程序

运行第一个Java程序

准备条件&#xff1a;已经安装了Java环境 1.在桌面上的空白处单击右键&#xff0c;然后在“新建&#xff08;W&#xff09;”下拉列表中选择“文本文档”&#xff08;即左键单击“文本文档”&#xff09;# 2. 打开文本文档&#xff0c;左键单击“新建文本文档.txt - 记事本” …
阅读更多...
Idea序列图插件-SequenceDiagram Core

Idea序列图插件-SequenceDiagram Core

&#x1f496;简介 SequenceDiagram Core 是一个 IntelliJ IDEA 插件&#xff0c;它允许开发者直接在 IDE中创建和编辑序列图&#xff08;Sequence Diagrams&#xff09;。序列图是 UML&#xff08;统一建模语言&#xff09;中的一种图表类型&#xff0c;用于描述对象之间如何…
阅读更多...
FFmpeg的简单使用【Windows】--- 指定视频的时长

FFmpeg的简单使用【Windows】--- 指定视频的时长

目录 功能描述 效果展示 代码实现 前端代码 后端代码 routers 》users.js routers 》 index.js app.js 功能描述 此案例是在上一个案例【FFmpeg的简单使用【Windows】--- 视频混剪添加背景音乐-CSDN博客】的基础上的进一步完善&#xff0c;可以先去看上一个案例然后再…
阅读更多...
Scrapy | 使用Scrapy进行数据建模和请求

Scrapy | 使用Scrapy进行数据建模和请求

scrapy数据建模与请求 数据建模1.1 为什么建模1.2 如何建模1.3如何使用模板类1.4 开发流程总结 目标&#xff1a; 1.应用在scrapy项目中进行建模 2.应用构造Request对象&#xff0c;并发送请求 3.应用利用meta参数在不同的解析函数中传递数据 数据建模 | 通常在做项目的过程中…
阅读更多...
周易解读：八卦01，八卦的卦象与记忆口诀

周易解读：八卦01，八卦的卦象与记忆口诀

八卦01 在前面呢&#xff0c;我们是讲解了太极&#xff0c;两仪&#xff0c;四象的知识。这些个知识呢&#xff0c;两仪还算是比较有用一些。太极&#xff0c;四象&#xff0c;其实就是一种了解性的知识。而本节的八卦的知识&#xff0c;那可就不一样了。八卦的知识&#xff0…
阅读更多...
nvm安装，node多版本管理

nvm安装，node多版本管理

卸载nodejs win R 输入 appwiz.cpl 删除 node.js查看node.js安装路径是否有残留&#xff0c;有就删除文件夹 删除下列路径文件&#xff0c;一定要检查&#xff0c;没删干净&#xff0c;nvm安装会失败 C:\Program Files (x86)\NodejsC:\Program Files\NodejsC:\Users{User}\…
阅读更多...
04 线性结构——栈（特性、进栈与出栈、栈顶指针、顺序栈和链式栈、相关功能的定义与代码实现）

04 线性结构——栈（特性、进栈与出栈、栈顶指针、顺序栈和链式栈、相关功能的定义与代码实现）

目录 1 栈的定义 2 相关概念 2.1 栈顶&#xff08;Top&#xff09; 2.2 栈底&#xff08;Bottom&#xff09; 2.3 空栈 2.4 栈的序列 2.5 出栈入栈与栈顶指针移动的关系 2.5.1 初始情况 top -1 2.5.2 初始情况 top 0 3 栈的应用&#xff1a;函数调用 4 栈的存储结…
阅读更多...
一个月学会Java 第17天 常用类(包装类、数学类、日期类、可变长字符串等等)

一个月学会Java 第17天 常用类(包装类、数学类、日期类、可变长字符串等等)

Day17 常用类(包装类、数学类、日期类、可变长字符串等等) 这一节会非常的简单和轻松&#xff0c;可以当做今天的学习就是在放松自己&#xff0c;因为这些常用类只需要记住类名和大概的方法在里面即可&#xff0c;翻一下看一下方法名都可以看出来的 目录 包装类数学类Math日期…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023