Java泛型的使用

已于 2023-11-03 09:18:47 修改
阅读量303 收藏
点赞数
文章标签： java 开发语言
于 2023-09-23 11:01:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wearewell258369/article/details/132390490
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、泛型概述

1.什么是泛型

泛型就是在接口、类的声明处或者在接口、类中某个属性、方法、返回值，通过一个标识来进行定义，这个标识就是类型参数，也叫参数化类型。因此泛型可以修饰接口、类、属性、方法和返回值。

2.泛型的历史

  1. 早在JDK1.5之后，在集合框架上就规范使用泛型结构来约束和限制集合的使用。通过泛型结构在集合上（就是在类、接口上），能够在实例化创建集合对象时，调用者通过泛型的类型参数，传入指定的数据类型（必须是类（对象）类型，基本数据类型需要使用包装类来替代）
  2. JDK1.5之后，改写了集合框架中的所有接口和类，为这些接口、类增加了泛型支持，因此在声明集合变量和创建集合对象时传入类型参数进行确定该集合对象下应该指定存放哪一种数据类型

3.引入泛型的意义

  1. 引入泛型，特别是集合在结合泛型的使用，增加了存储数据的安全性，有效避免了读取集合中元素的存在的ClassCastException运行时异常的出现
  2. 而且在集合泛型中指定集合元素的数据类型后，其在编译期间就已经约束了所存储的集合元素的数据类型，限制了其他不符合当前指定集合指定类型参数的数据元素，使代码更加健壮

二、自定义泛型结构

  1. 泛型修饰在接口和类的位置

  • 泛型类可以有多个参数例如<E1,E2,E3…>

  • 泛型类的构造方法不能像类一样声明使用泛型类，但是参数可以使用泛型参数

  • 实例化对象后，原本指定的泛型位置的结构必须是与指定的泛型类型一致

  • 泛型不同的引用不能相互赋值，例如List< Integer >和List< String >对象引用是不能相互赋值，如果是实例化List< Integer >
    list1=new List<>()和List< String > list2=new List<>()，如果把list1赋给集合变量list2尽管编译不通过，但是运行时只会把一个List对象加载到JVM虚拟机中-------也就是如果创建了两种泛型的对象，在运行时只有一个对象被加载到JVM虚拟机中

  • 泛型如果不指定将会被擦除，默认对应的类型是Object进行处理，但不能等价于Object（不能是其他类型引用赋值给基类的Object一样，譬如Object utilDate = new java.util.Date(1000);Date sqlDate = (java.sql.Date) utilDate;一样，父类是不能强转成子类，尽管可以骗过编译器，运行时会报ClassCastException），只要是使用了泛型，那么就绑定了泛型的类型是一路使用的、统一的

  • 泛型的接口或者抽象类是不能实例化泛型类对象的

  • 在JDK1.7之后，泛型结构实例化可以简写成：ArrayList list=new ArrayList<>()------类型可以进行推断

  • 泛型中不能使用基本数据类型，需要使用包装类进行替换

  • 在类/接口上声明的泛型结构，可以是非静态属性类型、非静态方法参数类型、非静态方法返回值类型。但是不能在静态方法中使用类的泛型（方法参数–T t）、静态变量（类变量）中使用泛型

  • 异常类不能使用泛型

  • 不能new E[]泛型

  • 父类有泛型，其子类可以选择保留泛型也可以选择指定泛型类型，也可以擦除不指定具体的泛型

①子类不保留父类的泛型，可擦除

class Father<T1,T2>{

}
//不保留父类泛型：可擦除，等价于Father<Object,Object>
class Son1 extends Father{

}

②子类保留父类泛型，并指定具体的类型

class Father<T1,T2>{

}
//保留父类类型：指定父类具体的泛型类型
class Son3 extends Father<Integer,String>{

}

③全部保留父类泛型

class Father<T1,T2>{

}
//全部保留父类泛型
class Son2<T1, T2> extends Father<T1,T2>{

}

④部分保留父类泛型

class Father<T1,T2>{

}
//部分保留父类泛型
class Son4<T1> extends Father<T1,Integer>{

}

⑤子类自定义泛型，不保留父类泛型

class Father<T1,T2>{

}
class Son5<A,B> extends Father{

}

⑥保留父类泛型,并指明父类的泛型类型

class Father<T1,T2>{

}
//保留父类泛型,并指明父类的泛型类型
class Son6<A,B> extends Father<Integer,String>{

}

⑦保留父类泛型

class Father<T1,T2>{

}
//保留父类泛型
class Son7<A,B,T1,T2> extends Father<T1,T2>{

}

⑧保留部分父类指定泛型

class Father<T1,T2>{

}
//保留部分父类指定泛型
class Son8<A,B,T2> extends Father<Integer,T2>{

}
  1. 泛型修饰在非静态类属性上：在类中声明一个泛型的属性，那么这个类就必须是泛型类或接口
class Person<T> {
    private int id;
    private String name;
    private T t;

    public Person() {
    }

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public T getT() {
        return t;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", t=" + t +
                '}';
    }
}
  1. 泛型修饰在非静态方法参数上、非静态方法返回值类型
 @Test
    public void test5(){
        Person<User> person = new Person<>();
        person.setT(new User(1001,"xxx",26));
        Person<User> person1 = new Person<>();
        person1.setT(new User(1002,"yyy",16));
        //System.out.println("person = " + person);
        List list = new ArrayList<>();
        list.add(person);
        list.add(person1);
        Object o = print1(list);
        System.out.println("o = " + o);
    }
    public static <T> List<T> print1(List<T> t){//只要参数中有泛型，其方法部需要添加<T>以此作为标记，但并不是返回值类型
        t.forEach(System.out::println);
        return t;
    }
  1. 非静态方法也可以被泛型化：不管该所在类是不是泛型类或接口，与之并没有关系

泛型方法的标识形式：访问修饰符 <泛型> 返回值类型【泛型】 方法名（泛型标识 参数名称 ）

public class MethodTest {
    public <T> T getT(T e){
        return null;
    }
}
  1. 不可以修饰在方法上（泛型的方法可以声明为静态的----但是因为泛型参数是在方法调用时就已经确定了，并非是实例化时才确定的， 如果是静态修饰，那么没有调用前就已经确定了，跟方法调用时才确认时机对不上

三、泛型在继承上的体现

如果A是B的子类或者子接口，那么G是具有泛型修饰的类或者接口，那么G是G子类或子接口不成立，这是需要注意的

  @Test
    public void test1(){
        Collection<String> list1 = new ArrayList<>();
        list1.add("123");
        list1.add("456");
        Collection<Object> list2 = new ArrayList<>();
        list2.add("123");
        list2.add(456);
//        list2=list1;//编译错误，Collection<String>并不是Collection<Object>上的子类，即使String是Object的子类
        printCollection1(list1);
        System.out.println("=====================");
        printCollection2(list2);
    }
    public static void printCollection1(Collection c){
        Iterator iterator = c.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

四、泛型标识作为通配符的使用：泛型尖括号中用？标识：<?>

  • 例如List<?>是List、List等子类的父类
  • 泛型类带有通配符是可以读取其子类集合中的所有元素，而且是安全的，因为不管list<?>的真实类型是什么，它都包括Object
  • 反观泛型类带有通配符是不可以添加集合元素的，因为我们并不知道List<?>的真实元素的数据类型是什么；但是它可以添加null这个集合元素，因为null是所有集合的类型成员，不管你是任何其他数据类型的集合，它都是其集合元素中的一员
 @Test
    public void test2(){
        List<?> list=null;
        list=new ArrayList<String>();
        list=new ArrayList<Object>();
//        list.add(2);//编译不通过，不能忘集合里面添加元素；但是可以获取集合中的元素赋给他们的父类List<?>
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("123456");
        list1.add("xxx");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(1234567);
        list2.add(123456);
        getRead(list1);
        System.out.println("=========================");
        getRead(list2);
    }
    public static void getRead(List<?> list){
        for (Object o:list
             ) {
            System.out.println("o = " + o);
        }
    }

 @Test
    public void test1(){
        ArrayList<Object> list1 = new ArrayList();
        list1.add(123);
        list1.add('A');
        ArrayList<String> list2 = new ArrayList();
        list2.add("xxx");
        list2.add("yyy");
        List<?>  list=null;
        list=list1;
        //list的添加操作:不能在添加其他类型数据，可以添加null
//        list.add("AA");
//        list.add('A');
        list.add(null);
        //list的获取操作：允许获取数据，读取的数据为Object类型的
        Object o = list.get(0);
        System.out.println("o = " + o);
        print(list);
       // System.out.println(print(list));
        System.out.println("================================");
        list=list2;
        print(list);
    }
    public static void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println("next = " + next);
        }
    }
  • 通配符不能用在其他位置上
  • 不能用在泛型方法的泛型标识上
public static <?> void getRead(List<?> list){
        for (Object o:list
             ) {
            System.out.println("o = " + o);
        }
    }
  • 不能用在泛型类的声明上：public class test<?>{}
  • 不能用在创建集合对象上：List<?> list=new ArrayList<?>
  • 有限制的通配符使用
  • ?：代表着所有泛型引用的调用
  • 通配符指定上线：**<? extends 类>**使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
  • 通配符指定下线：**<? super 类>**使用时指定的类必须是不小于该操作类，即是>=
@Test
    public void test3(){
        List<? super User> list=null;
        List<User> list1=new ArrayList<>();
        List<Teacher> list2=new ArrayList<>();
        List<Object> list3=new ArrayList<>();
        list=list1;
//        list=list2;编译不通过：因为Teacher类是User的子类，比通配符实操的子类还要小，所以不符合规则
        list=list3;
        list.add(new User());
        list.add(new Teacher());
//        list.add(new Object());//编译不通过：做添加时，比通配符实操的类还要小才能添加成功：实操的子类才能添加
    }
 @Test
    public void test1(){
        ArrayList<Object> list1 = new ArrayList();
        list1.add(123);
        list1.add('A');
        ArrayList<String> list2 = new ArrayList();
        list2.add("xxx");
        list2.add("yyy");
        List<?>  list=null;
        list=list1;
        //list的添加操作:不能在添加其他类型数据，可以添加null
//        list.add("AA");
//        list.add('A');
        list.add(null);
        //list的获取操作：允许获取数据，读取的数据为Object类型的
        Object o = list.get(0);
        System.out.println("o = " + o);
        print(list);
       // System.out.println(print(list));
        System.out.println("================================");
        list=list2;
        print(list);
    }
    public static void print(List<? extends Object> list){
        Iterator<? extends Object> iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println("next = " + next);
        }
    }

五、泛型在开发场景中的应用

  • 一个关于操作数据库后台数据的增删改查类
public class DAO<T> {
    private Map<String,T> map=new HashMap<>();

    //保存T类型的对象到Map成员变量中
    public void insert(String id,T entity){
       map.put(id, entity);
    }
    public void show(T t){

    }
    //从map中获取id对应的对象
    public T get(String id){
        T t = map.get(id);
        return t;
    }
    //从map中修改对应id的值
    public void update(String id,T entity){
        boolean b = map.containsKey(id);
        if (b){
            map.put(id,entity);
        }

    }
    //返回map中存放的所有T的对象
    public List<T> list(){
        Collection<T> values = map.values();
        List<T> list = new ArrayList<>();
        for (T t:values) {
            list.add(t);
        }
        return list;
    }
    //删除指定的id对象
    public void delete(String id){
        map.remove(id);
    }
}
  • 相关实体类
public class User extends Creature {
    private int id;
    private String name;
    private int age;

    public User() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (id != user.id) return false;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + age;
        return result;
    }
}
  • 相关测试类
public class UserDaoTest {
    @Test
    public void test1(){
        DAO<User> dao = new DAO<>();
        dao.insert("101",new User(1001,"XXX",25));
        dao.insert("102",new User(1002,"YYY",16));
        dao.insert("103",new User(1003,"ZZZ",19));
        List<User> list = dao.list();
        System.out.println("list = " + list);
        System.out.println("dao.get(\"101\") = " + dao.get("101"));
        dao.delete("103");
        List<User> list1 = dao.list();
        System.out.println("list1 = " + list1);
        dao.update("102",new User(1002,"MMM",11));
        List<User> list2 = dao.list();
        System.out.println("list2 = " + list2);
    }
}
比别人更努力
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java泛型使用
12-22
Java泛型使用 1. 泛型 1.1 什么是泛型，为什么引入泛型 在项目中，我们的功能代码往往要考虑之后的复用！！！这要求功能代码尽可能的支持更多类型，在不考虑泛型的情况下,如果需要更换数据类型，只能重新完成对应...
Java泛型定义与用法实例详解
08-27
泛型的引入使得Java语言更加灵活和强大，本文将详细介绍Java泛型的定义、原理、使用方法及相关操作注意事项。 一、泛型的由来 泛型的出现是为了解决早期Java集合框架中的类型安全问题。在早期Java集合框架中，集合...
12、Java基础之泛型的使用
xiaosuxueJava的博客
01-09 982
Java泛型的使用
Java基础：泛型的使用
weixin_50835087的博客
08-11 1053
集合、类、方法中泛型的使用以及泛型在继承中的体现
2024年Java最全Java 泛型使用（类、方法、接口协议、类型通配符、通配符上下限，超硬核
最新发布
2401_84103771的博客
05-05 1036
给大家送一个小福利附高清脑图，高清知识点讲解教程，以及一些面试真题及答案解析。送给需要的提升技术、准备面试跳槽、自身职业规划迷茫的朋友们。本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取范例:此处T可以随便写为任意标识，常见的如T、E、K、 V等形式的参数常用于表示泛型。定义一个公用泛型类// 定义私有属性// 重写 get 方法return t;// 重写 set 方法。
Java---＞toString方法
Mrrr_Li的博客
10-04 115
toString 是源自java Object类，在Object 内定义为：返回一个 类名@hashcode的字符串，可以overridden 用来返回 你认为有用的信息， toStrng 没有arguments override：public String toString（）{ // insert you code return “informations” } 因为在java中 Object类是基类，所以每个类都会有toString方法。 System.out.println（Object）实际上就是
深入理解Java中泛型的使用
qq_28068311的博客
12-15 591
深入理解泛型的使用，不仅能够更好地应用它解决实际问题，还有助于写出更加健壮和可维护的 Java 代码。Java 泛型是从 Java 5 开始引入的，它为程序员提供了编写更灵活、更安全的代码的工具。通过在编译时提供更丰富的类型信息，泛型有助于捕获并预防一些运行时错误，提高代码的可读性和可维护性。泛型在处理继承关系时也有一些需要注意的地方，比如泛型类的继承、泛型方法的覆盖等。在文章的最后，介绍一些使用泛型时的最佳实践和注意事项，包括避免原始类型、注意类型擦除的影响等。，它们分别用于限定通配符的范围。
Java泛型的介绍和应用-1
weixin_39158966的博客
04-10 158
泛型是一种可以表示数据类型的 数据类型E 称为泛型泛（广泛）型（类型）===>integer，String，Dog，……泛型又称参数化类型，是jdk5.0出现的新特性，解决数据类型的安全性问题在类声明或者实例化时只要指定好需要的具体类型即可Java泛型可以保证如果程序在编译时没有发出警告，运行就不会产生ClassCastException异常。
Java泛型使用详细分析.pdf
03-16
在Java泛型使用详细分析中，我们将深入探讨Java泛型的基本概念、泛型的使用场景、泛型的语法、泛型在集合上的使用等方面的知识点。 一、为什么要使用泛型？ 在Java语言中，我们经常需要使用集合来存储数据，但是...
Java泛型的使用限制实例分析
08-25
"Java泛型的使用限制实例分析" Java泛型的使用限制是Java编程语言中的一個重要概念，泛型的使用可以提高代码的可读性和安全性，但是需要注意一些使用限制，否则可能会出现编译错误或运行时异常。 首先， Java泛型...
【数据结构】Java 泛型详解与应用
the_yufeng的博客
06-22 225
Java 泛型是一种强大的特性，它提供了在编译时期进行类型检查和类型安全的能力。本文将介绍泛型的基本概念、语法和常见应用场景，帮助您理解和灵活应用这一重要特性。
JAVA-泛型的简单使用方法以及高级使用
梦的彼岸花
10-11 702
一、通常使用类泛型方法： 1.类泛型方法的使用 class Demo{ public void Show(T t){ System.out.println("show:"+t); } public void Print(T t){ System.out.println("print:"+t); } } 2.方法泛型的使用 class Demos{ public voi
java常见面试题：什么是泛型？泛型有哪些应用场景？
dxl920807的博客
01-02 807
泛型是程序设计语言的一种特性，它允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。以上就是一些泛型可能会失效的场景，如需了解更多信息，建议咨询专业技术人员或查阅编程语言相关书籍。以上就是一些泛型的应用场景，它们展示了泛型在提高代码安全性、灵活性和可维护性方面的优势。
Java泛型：定义、使用与实战
Jz_Stu的博客
03-26 1115
泛型是Java SE 5.0中引入的一个新特性，它提供了编译时类型安全，减少了类型转换的代码，并提高了代码的可重用性。泛型，顾名思义，就是广泛的数据类型。在Java中，泛型允许我们在定义类、接口和方法时使用类型参数。这些类型参数在类、接口或方法被实例化时（即创建对象时）被具体的类型替换。这样，我们可以编写更加通用的代码，提高代码的可重用性。当我们需要自定义一些数据结构（如栈、队列等）时，泛型可以帮助我们编写更加通用的代码。通过使用泛型，我们可以使这些数据结构支持任意类型的元素。
【Java基础】泛型（一）-基础使用
couthz
02-16 509
本文以Java的官方文档为参考，辅以代码示例，尽可能详尽的叙述泛型的每一个特性 泛型（Generics）也称为参数化类型（parameterized types），也就是将类型本身作为接口、类、方法中的参数，相应地声明泛型接口、泛型类、泛型方法，在具体调用时再传入类型参数。从而实现同一种接口、类、方法适用于不同的类型。
Java 泛型的简介和使用
it_xushixiong的博客
04-27 318
Java 泛型是一项非常重要的特性，它可以使代码更加类型安全、可读性更高、可维护性更好。在编写 Java 程序时，我们应该尽可能地使用泛型，以提高代码的质量和效率。同时，也需要注意泛型的局限性，避免在使用泛型时出现不必要的问题。
Java中泛型的使用
weixin_49329785的博客
08-22 2420
一、泛型的意义 二、泛型的使用 1.jdk 5.0新增特性 2.在集合中使用泛型： 总结： A.集合接口或集合类在jdk5.0时都修改为带泛型的结构。 B.在实例化集合类时，可以指明具体的泛型类型。 C.指明完以后，在集合类或接口中凡是定义类或接口时，内部结构(比如：方法、构造器、属性等)使用类的泛型的位置， 都指定为实例化的泛型类型。比如：add(E e) --->实例化以后：add(Integer e) D.注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数...
JAVA泛型-泛型方法的定义和使用
热门推荐
northcastle的博客
10-23 5万+
1.泛型方法的定义和语法 1.1 定义 泛型方法 是在调用方法的时候指明泛型的具体类型。 【泛型方法 能够使方法独立于类的处理指定的类型。】 1.2 语法 修饰符 <T,E,…> 返回值类型 方法名（形参列表）{ 。。。。。。 } 修饰符与返回值类型中间的 泛型标识符 <T,E,…>,是 泛型方法的标志，只有这种格式声明的方法才是泛型方法。 泛型方法声明时的 泛型标识符 <T,E,…> 表示在方法可以使用声明的泛型类型。 与泛型类相同，泛型标识符可以是任意类
java泛型方法的使用
05-28
Java泛型方法是一种在方法中使用泛型类型的技术，可以让我们编写出更加通用的代码，提高代码的可复用性和安全性。下面是使用Java泛型方法的一些基本步骤： 1. 在方法的返回类型前加上尖括号，用来指明泛型类型的名称，例如：public <T> T myMethod() {} 2. 在方法的参数列表中使用泛型类型，例如：public <T> void myMethod(T parameter) {} 3. 在方法中使用泛型类型，例如：T myVariable = new T(); 4. 调用泛型方法时，可以显式地指定泛型类型，例如：myMethod<String>("hello"); 需要注意的是，Java泛型方法并不是必须的，只有在需要处理不同类型的数据时才需要使用。同时，泛型方法的使用也需要谨慎，避免出现类型转换错误或者编译错误等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值