Java 泛型

已于 2022-07-18 17:05:32 修改
阅读量81 收藏
点赞数
文章标签： java 开发语言
于 2022-07-18 17:00:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62918925/article/details/125855353
版权

目录

文章目录

泛型

1. 泛型的理解和好处

案例：

/*
请编写程序，在ArrayList中，添加了个Dog对象
Dog对象含有name和age,并输出name和age(要求使用getXxx())
 */

import java.util.ArrayList;

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

        // 使用传统方法解决
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));

        // 假如不小心加入了 Cat，运行会报异常
//        arrayList.add(new Cat("招财猫",2));

        // 遍历
        for (Object o : arrayList) {
            // 向下转型 Object-->Dog
            Dog dog = (Dog) o;
            System.out.println(dog.getName() + ":" + dog.getAge());
        }

    }
}

class Dog {
    public String name;
    public int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

class Cat {
    public String name;
    public int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

使用以上解决办法出现的问题：

  1. 不能对加入到集合ArrayList中的数据类型进行约束；
  2. 遍历的时候需要类型转换，如果数据量巨大，影响代码效率。

所以可以使用泛型进行改良：

/*
请编写程序，在ArrayList中，添加了个Dog对象
Dog对象含有name和age,并输出name和age(要求使用getXxx())
*/

import java.util.ArrayList;

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

        // 使用泛型
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));

        // 假如不小心加入 Cat，会报错
//        arrayList.add(new Cat("招财猫",2));

        // 遍历
        for (Dog dog : arrayList) {
            System.out.println(dog.getName() + ":" + dog.getAge());
        }
    }
}

改进代码说明：

  1. ArrayList< Dog >表示存放到ArrayList集合中的元素是Dog类型；
  2. 如果编译器发现添加的类型不满足要求，就报错；
  3. 遍历时，可以直接取出Dog而不是Object，不需要转型。

1.1 好处

  • 编译时，检查添加元素的类型，提高了安全性；
  • 减少了类型转换的次数。

2. 泛型介绍

  • 泛型又称参数化类型，是Jdk5.0 出现的新特性，解决数据类型的安全性问题；
  • 在类声明或实例化时只要指定好需要的具体的类型即可；
  • Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮；
  • 泛型的作用是：可以在类声明时通过个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。

Demo：

public class Generic02 {
    public static void main(String[] args) {
        Person<String> person = new Person<String>("cat");
        person.show();    // class java.lang.String

        Person<Integer> person1 = new Person<Integer>(100);
        person1.show();    // class java.lang.Integer

    }
}
// E 的具体类型在定义 Person 对象的时候指定，即在编译期间，就确定E是什么类型
class Person<E>{
    public E s; // E 表示 s 的数据类型

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

    public E f(){   // E 作返回类型
        return s;
    }
    public void show(){
        System.out.println(s.getClass());   // 显示 s 的运行类型
    }
}

注意： E 的具体类型在定义 Person 对象的时候指定，即在编译期间，就确定E是什么类型。

3. 泛型的语法

3.1 泛型的声明

interface 接口< T >{}和class 类<K，V> {}
//比如: List ，ArrayList
说明:

  1. 其中，T,K,V不代表值，而是表示类型；
  2. 任意字母都可以。常用T表示，是Type的缩写。

3.2 泛型的实例化

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

  1. List< String > strList = new ArrayList< String > ()；
  2. Iterator< Customer > iterator = customers.iterator()；

3.3 举例说明

Demo：

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

import java.util.*;

public class GenericExercise {
    public static void main(String[] args) {
        // 1. HashSet
        HashSet<Student> set = new HashSet<>();

        // 放入3个学生对象
        set.add(new Student("jack", 20));
        set.add(new Student("tom", 21));
        set.add(new Student("john", 19));
//        set.add(100);   // 使用泛型后，该语句报错

        // 增强for遍历
        for (Student student : set) {
            System.out.println(student);
        }
        
        // 2. HashMap
        HashMap<String, Student> hashMap = new HashMap<>();
        hashMap.put("smith", new Student("smith", 20));
        hashMap.put("allen", new Student("allen", 21));
        hashMap.put("mary", new Student("mary", 19));

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

        }
    }

}

class Student {
    public String name;
    public int age;

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

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

4. 泛型使用细节

使用的注意事项和细节：

  1. interface List< T >{} , public class HashSet< E >{}…等等
    说明：T， E只能是引用类型，不能是基本数据类型。

    ArrayList<Integer> list = new ArrayList<Integer>();	// ok
        ArrayList<int> list2 = new ArrayList<int>();    // 错误

  2. 在给泛型指定具体类型后，可以传入该类型或者其子类类型。

    import java.util.ArrayList;

public class GenericDetail {
    public static void main(String[] args) {
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();	//class com.generic.A
        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();	//class com.generic.B

    }
}
class A{}
class B extends A{}

class Pig<E>{
    E s;

    public Pig(E s) {
        this.s = s;
    }
    public void f(){
        System.out.println(s.getClass());
    }
}

  3. 将< >去掉，默认给的泛型是Object。

4.1 练习

定义Employee类
1）该类包含： private成员变量name，sal，birthday， 其中birthday为MyDate类的对象；
2）为每一个属性定义getter, setter方法；
3）重写toString方法输出name，sal， birthday；

4） MyDate类包含：private成员变量month，day，year；并为每一个属性定义getter，setter方法；
5）创建该类的3个对象，并把这些对象放入ArrayList集合中(ArrayList 需使用泛型来定义)，对集合中的元素进行排序，并遍历输出；

排序方式调用ArrayList 的sort方法，传入Comparator对象[使用泛型]，先按照name排序如果name相同，则按生日日期的先后排序。（即：定制排序）

import java.util.ArrayList;
import java.util.Comparator;

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

        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("tom", 20000, new Mydate(2000, 11, 11)));
        employees.add(new Employee("tom", 12000, new Mydate(2000, 10, 12)));
        employees.add(new Employee("smith", 50000, new Mydate(1995, 12, 6)));

        System.out.println("employees=" + employees);

        // 排序
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee emp1, Employee emp2) {
                // 先对传入参数进行验证   （排除Employee子类）
                if (!(emp1 instanceof Employee && emp2 instanceof Employee)) {
                    System.out.println("类型不匹配~");
                    return 0;
                }
                // 先比较 name
                int result = emp1.getName().compareTo(emp2.getName());
                if (result != 0) {
                    return result;
                }
                return emp1.getBirthday().compareTo(emp2.getBirthday());
            }
        });

        System.out.println("=== 排序 ===");
        System.out.println("employees" + employees);

    }
}

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) {    // 把日期比较放在这里
        //  比较 year
        int y = year - o.getYear();
        if (y != 0) {
            return y;
        }
        // year 相同就比较 month
        int m = month - o.getMonth();
        if (m != 0) {
            return m;
        }
        // 如果 month 相同,直接返回 day 的差值
        return day - o.getDay();

    }
}

class Employee {
    private String name;
    private double sal;
    private Mydate birthday;

    public Employee(String name, double 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 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;
    }

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

该程序输出的结果如下：

5. 自定义泛型

5.1 自定义泛型类

注意细节：

  1. 普通成员可以使用泛型(属性、方法)；
  2. 使用泛型的数组，不能初始化；
  3. 静态方法中不能使用类的泛型；

Demo：

class Tiger<T,R,M>{
    String name;
    R r;	// 属性使用泛型
    M m;
    T t;
//    T[] ts = new T[6];	// 可以定义但不能初始化
    
    public R getR() {	// 方法使用泛型
        return r;
    }

    public void setR(R r) {
        this.r = r;
    }
    // 静态方法和属性不能使用泛型（加载的原因）
//    static R r2;
//    public static void m1(M m){}
}

5.2 自定义泛型接口

注意细节：

  1. 接口中，静态成员也不能使用泛型（这个和泛型类规定一样）；
  2. 泛型接口的类型，在继承接口或者实现接口时确定；
  3. 没有指定类型，默认为Object。

Demo：

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

    }
}

interface IUsb<U, R> {
//    R 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;
    }
}

// 继承接口时确定泛型
interface IA extends IUsb<String, Integer> {
}

class AA implements IA {    // 实现 IUsb 接口的所有方法
    @Override
    public Integer get(String s) {
        return null;
    }

    @Override
    public void hi(Integer integer) {

    }

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

    }
}

5.3 自定义泛型方法

基本语法：

​ 修饰符 < T,R… > 返回类型 方法名（参数列表）{ }

注意细节：

  1. 泛型方法，可以定义在普通类中，也可以定义在泛型类；
  2. 当泛型方法被调用时，类型会确定；
  3. public void eat(E e) {},修饰符后没有<T,R…> ，eat方法不是泛型方法，而是使用了泛型；
  4. 可以使用泛型类声明的泛型，也可以使用自己声明泛型。

Demo：

public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马",100);  // 编译器会根据值确定类型
    }
}

class Car {  // 普通类
    public void run() {    // 普通方法
    }

    public <T, R> void fly(T t, R r) {    // 泛型方法
    }
}

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

    public <U, M> void swim(U u, M m) {    // 泛型方法
    }
}

5.4 练习

public class CustomMethodGenericExercise {
    public static void main(String[] args) {
        Apple<String, Integer, Double> apple = new Apple<>();
        apple.fly(10);  // Integer
        apple.fly(new Dog());   // Dog
    }

}

class Apple<T, R, M> {
    public <E> void fly(E e) {
        System.out.println(e.getClass().getSimpleName());
    }

    //    public void eat(U u){}  // 报错
    public void run(M m) {
    }  // ok
}

6. 泛型的继承和通配符

说明：

  1. 泛型不具备继承性；

    List< Object > list = new ArrayList < String>(); //该写法错误的
  2. <?> ：支持任意泛型类型；
  3. <? extends A>：支持A类以及A类的子类，规定了泛型的上限；
  4. <? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限。

Demo：

public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("xx");    // ok
//        List<Object> list= new ArrayList<String>(); // 报错

        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<AA> list3 = new ArrayList<>();
        ArrayList<BB> list4 = new ArrayList<>();
        ArrayList<CC> list5 = new ArrayList<>();
        
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);
        
//        printCollection2(list1);    // ×
//        printCollection2(list2);    // ×
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);
        
        printCollection3(list1);
//        printCollection3(list2);    // ×
        printCollection3(list3);
//        printCollection3(list4);    // ×
//        printCollection3(list5);    // ×

    }

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

    }

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

    }

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

    }

}

class AA {
}

class BB extends AA {
}

class CC extends BB {
}

7. 作业

定义个泛型类DAO< T >，在其中定义一个Map成员变量，Map的键为String类型，值为T类型，分别创建以下方法：
(1) public void save(String id，T entity)：保存 T类型的对象到Map成员变量中。
(2) public T get(String id)：从map中获取id对应的对象。
(3) public void update(String id，T entity)：替换map中key为id的内容，改为entity对象。
(4) public List< T > list()：返回map中存放的所有T对象。
(5) public void delete(String id)：删除指定id对象。

定义一个User类:
该类包含: private成员变量(int类型) id, age；(String 类型) name。
创建DAO类的对象，分别调用其 save、get、 update、 list、 delete 方法来操作User对象，
使用Junit单元测试类进行测试。

import org.junit.jupiter.api.Test;
import java.util.List;

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

    }
    @Test
    public void testList(){
        //  给 T 指定类型是 User
        DAO<User> dao = new DAO<>();
        dao.save("001",new User(1,10,"jack"));
        dao.save("002",new User(2,18,"tom"));
        dao.save("003",new User(3,37,"smith"));

        List<User> list = dao.list();
        System.out.println(list);

        System.out.println(dao.get("001"));

        dao.update("003",new User(3,40,"mary"));
        dao.delete("001");
        list = dao.list();  // 需要重新获取
        System.out.println("修改后\n"+list);

    }
}

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 + '\'' +
                '}';
    }
}

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

    public void save(String id, T entity) {
        map.put(id, entity);
    }

    public T get(String id) {
        return map.get(id);
    }

    public void update(String id, T entity) {
        map.put(id, entity);
    }

    // 遍历 map [k-v] ，将所有的 value （T entity），封装到 ArrayList返回
    public List<T> list() {
        ArrayList<T> list = new ArrayList<>();

        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            list.add(get(key)); // 直接用本类中的 get（）方法
        }
        return list;
    }

    public void delete(String id) {
        map.remove(id);
    }

}

测试的结果为：

From：零基础 快速学Java

鱼尾巴选手
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java泛型总结
04-09
### Java泛型总结 #### 一、Java泛型概述 Java泛型是在JDK5之后引入的一个特性，它提供了一种类型安全的机制，用于指定集合或其他数据结构中的元素类型。通过使用泛型，程序员可以在编译阶段检测类型错误，避免了...
Java泛型的简单实例
09-04
Java泛型的简单实例 Java泛型是一种类型系统特性，它允许开发者在编写代码时指定类型参数，从而使代码更加灵活、可重用和类型安全。在本文中，我们将通过一个简单的示例来介绍Java泛型的使用。 泛型的概念 泛型是...
大白话说Java泛型：入门、使用、原理
weixin_34014555的博客
01-15 228
文章首发于【博客园-陈树义】，点击跳转到原文《大白话说Java泛型：入门、使用、原理》 远在 JDK 1.4 版本的时候，那时候是没有泛型的概念的。当时 Java 程序员们写集合类的代码都是类似于下面这样： List list = new ArrayList(); list.add("www.cnblogs.com"); list.add(23); String name = (String)li...
java集合
weixin_45682831的博客
04-06 101
Java中集合类是放在java.util中，是一个用来存放对象的容器。 1、只能存放对象，不能存放int等类型，存的是对应的是Integer等对象 2、存的是对象的引用，对象本身是放在堆内存中 3、可以存放不同类型的对象（因为实现的时候使用了泛型），不建议使用。 常用的三种集合接口： List：继承自Collection。可以存在相同的对象，有序的。具体实现类有ArrayList，LinkedLi...
【java8新特性】：常见的函数式接口
AS011x的博客
09-19 711
Jdk8提供的函数式接口都在java.util.function包下，Jdk8的函数式类型的接口都有@FunctionInterface注解所标注，但实际上即使没有该注解标注的有且只有一个抽象方法的接口，都可以算是函数式接口。
java泛型详解
weixin_52385232的博客
06-25 2425
java泛型详解
java（泛型）
weixin_63954483的博客
06-28 535
泛型的好处：1、编译时，检查添加元素的类型，提高了安全性2、减少了类型转换的次数，提高效率概念：1、泛型又称参数化类型，解决数据类型的安全性问题2、在类声明或实例化时只要指定好需要的具体类型即可3、java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。会使代码更简洁更健壮4、泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值类型，或者是参数类型注意事项：1、E只能是引用类型，不可以是基本数据类型 2、在指定泛型具体
Java泛型定义与用法实例详解
08-27
Java泛型定义与用法实例详解 Java泛型是Java语言中的一种重要机制，用于在编译期检查类型安全，避免在运行期引发ClassCastException。泛型的引入使得Java语言更加灵活和强大，本文将详细介绍Java泛型的定义、原理、...
详谈Java泛型中T和问号(通配符)的区别
08-28
Java泛型中T和问号(通配符)的区别 Java泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、...
java 泛型
04-07
Java泛型是Java编程语言中的一个关键特性，它在2004年随着Java SE 5.0的发布而引入。泛型允许程序员在代码中使用类型参数，从而增加了代码的类型安全性和重用性。它能够帮助我们避免在运行时出现ClassCastException...
java泛型中的E，K，V，T，U，S
斜阳雨陌
07-03 9511
在 Java 中，类、类对象、泛型之间的转换
暗诺星刻的博客
02-21 1万+
Java中，类、类对象、泛型之间的转换R为非泛型获得类通过类型名来获得类通过对象来获得类通过类名字符串来获得类通过类来获得类名字符串通过类来获得对象使用R的无参数构造器来创建对象使用R的有参数构造器来创建对象T为泛型通过泛参来得到Class对象通过泛参来创建实例对象通过泛型非空引用来得到Class对象通过Class对象来得到泛参通过Class对象来创建实例对象使用T的无参数构造器来创建对象使用T的有参数构造器来创建对象 R为非泛型   这里说的类是指某个对象所属的类所对应的类Class<?>的对
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 7万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
java基础之泛型T，E，K，V
qq_41720578的博客
04-17 1996
前言 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 泛型的好处: ...
java带参数的类setter_关于泛型：带有getter和setter的java类属性，这不应该是常见的...
weixin_39801165的博客
02-28 444
本问题已经有最佳答案，请猛点这里访问。我已经用Java开发了5年多了。现在，当我开始编写新的类或代码时，我首先要定义类的属性。因此，每次我的失望时，我都需要点击eclipse生成getter和setter。这是更清晰的代码，最终更容易理解。但我喜欢抽象和使用OOP和泛型。因此，人们需要使用Java原语的特定原因或者我们可以在Java中创建这样的类以始终具有getter和setter，并且仍然在Ja...
JAVA泛型通配符T，E，K，V区别，T以及Class<T>，Class<?>的区别
qq_31433709的博客
02-01 1万+
先"先感谢"和转载于https://www.jianshu.com/p/95f349258afb1. 先解释下泛型概念 泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。Java语言引入泛型的好处是安全简单。 在Java SE 1.5之前，没有泛型的情况的下，通
（javaweb）请求响应postman
2301_79144798的博客
08-08 484
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 272
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 237
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Java泛型深入解析
Java泛型是自JDK 1.5版本引入的一种强大的编程特性，它允许在类、接口和方法中使用类型参数，以增强类型安全性和代码重用性。本教程将深入讲解这一主题，帮助开发者理解和应用泛型。 1. **泛型基础** 泛型的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值