Java泛型

已于 2022-08-06 22:07:21 修改
阅读量106 收藏
点赞数
分类专栏： 狂神说Java学习 文章标签： java jvm 开发语言
于 2022-08-04 19:15:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61467488/article/details/126158828
版权
本文详细介绍了Java中的泛型概念，包括泛型在集合中的使用，如何自定义泛型类和接口，以及泛型方法。同时，讨论了泛型的类型安全、类型擦除和通配符的限制。通过示例展示了泛型在实际编程中的应用场景，如DAO操作和数据转换。此外，还探讨了泛型在继承关系中的特性及其限制条件。
摘要由CSDN通过智能技术生成

一、泛型的使用

把元素的类型设计成一个参数，这个类型参数叫做泛型。

  • 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
  • 从JDK1.5以后，Java引入了"参数化类型"的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象。
  • JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

总结：
① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
② 在实例化集合类时，可以指明具体的泛型类型。
③ 指明之后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置都指定为实例化的泛型类型。比如：add(E e) —> 实例化之后：add(Integer e)
④ 注意：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，用包装类替换。
⑤ 如果实例化时没有指明泛型的类型。默认类型为java.lang.Object类型。


public class GenericTest {

    //在集合中不使用泛型的情况：
    @Test
    public void test1() {
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //问题一：类型不安全
        //list.add("Tom");

        for(Object score : list) {
            //问题二：强转时，可能出现ClassCastException
            int stuScore = (int) score;
            System.out.println(stuScore);
        }
    }

    //在集合中使用泛型的情况：以ArrayList为例
    @Test
    public void test2() {
        ArrayList<Integer> list = new ArrayList<Integer>(); //不能使用基本数据类型
        //需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //编译时，就会进行类型检查，保证数据的安全
        //list.add("Tom");

        //方式一：
        for (Integer score : list) {
            //避免了强转操作
            int stuScore = score;
            System.out.println(stuScore);
        }
        //方式二：
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer stuScore = iterator.next();
            System.out.println(stuScore);
        }
    }

    //在集合中使用泛型的情况：以HashMap为例
    @Test
    public void test3() {
        //Map<String, Integer> map = new HashMap<String, Integer>();
        //jdk7新特性：类型推断
        Map<String, Integer> map = new HashMap<>();

        map.put("Tom", 87);
        map.put("Jerry", 87);
        map.put("Jack", 67);

        //泛型的嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key + "----" + value);
        }
    }
}

二、如何自定义泛型结构：泛型类、泛型接口；泛型方法

泛型类、泛型接口
  1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。
    比如：<E1, E2, E3>
  2. 泛型类的构造器如下：public GenericClass(){}。
    而下面是错误的：public GenericClass<E>(){}
  3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
  4. 泛型不同的引用不能相互赋值。
    （尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是在运行时只有一个ArrayList被加载到JVM中。）
  5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
  6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
  7. jdk1.7，泛型的简化操作：ArrayList<Fruit> first = new ArrayList<>();
  8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
  9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
  10. 异常类不能是泛型的。
  11. 不能使用new E[ ]。但是可以：E[ ] elements = (E[ ]) new Object[capacity];
    参考：ArrayList源码中声明：Object[ ] elementData，而非泛型参数类型数组。
  12. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型；
    - 子类不保留反类的泛型：按需实现
       没有类型 擦除
       具体类型
    - 子类保留父类的泛型：泛型子类
       全部保留
       部分保留

结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型。

package com.sgggeneric;
/*
自定义泛型类
 */
public class Order<T> {

    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型

    T orderT;

    public Order() {};

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
}

public class SubOrder extends Order<Integer> { //SubOrder：不是泛型类}


public class SubOrder1<T> extends Order<T>{ //SubOrder1<T>：仍然是泛型类}


public class GenericTest1 {

    @Test
    public void test1() {

        Order order = new Order();
        //如果定义了泛型类，实例化时没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果定义了类是带泛型的，建议在实例化时要指明类的泛型
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<>();

        order1.setOrderT("AA:Hello");

    }

    @Test
    public void test2() {
        SubOrder sub1 = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
        sub1.setOrderT(123);

        SubOrder1<String> sub2 = new SubOrder1<>();
        sub2.setOrderT("order2...");
    }

    @Test
    public void test3() {
        //泛型不同的引用不能相互赋值
        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = null;
//        list1 = list2;
    }

    //测试泛型方法
    @Test
    public void test4() {
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1, 2, 3, 4};
        //泛型方法在调用时，指明泛型参数的类型
        List<Integer> list = order.copyFromArrayToList(arr);

        System.out.println(list); //[1, 2, 3, 4]
    }
}

子类指定或保留父类的泛型

class Father<T1, T2> {
}
//子类不保留父类的泛型
//1)没有类型  擦除
class Son1 extends Father { //等价于class Son extends Father<Object,, Object>{}
}

//2)具体类型
class Son2 extends Father<Integer, String> {
}
//子类保留父类的泛型
//1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
//2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

子类增加自己的泛型

class Father<T1, T2> {
}
//子类不保留父类的泛型
//1)没有类型  擦除
class Son<A, B> extends Father{
}

//2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
//子类保留父类的泛型
//1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
//2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}
泛型方法

泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
        即，泛型方法所属的类是不是泛型类都没有关系。
泛型方法是可以声明为静态的。原因：泛型参数是在调用方法时确定的，并非在实例化类时确定的。

    public <E> List<E> copyFromArrayToList(E[] arr) {

        ArrayList<E> list = new ArrayList<>();

        for (E e : arr) {
            list.add(e);
        }
        return list;
    }

数据库中的实际应用

/*
DAO：data(base) access object
 */

import java.util.List;

//数据库的一些基本操作；添删改查
public class DAO<T> {//表的共性操作的DAO
    //添加一条记录
    public void add(T t) {}

    //删除一条记录
    public boolean remove(int index) {return false;}

    //修改一条记录
    public void update(int index, T t) {}

    //查询一条记录
    public T getIndex(int index) {return null;}

    //查询多条记录
    public List<T> getForList(int index) {return null;}
    
    //泛型方法
    //举例：获取表中一共有多少条记录？获取最大的员工入职时间？  更改泛型的类型
    public <E> E getValue() {
        return null;
    }
}

public class Customer {
}

public class CustomerDAO extends DAO<Customer> {//只能操作某一个表的DAO
}

public class DAOTest {

    @Test
    public void test1() {
        CustomerDAO dao1 = new CustomerDAO();

        dao1.add(new Customer());
        List<Customer> list = dao1.getForList(10);
    }
}

三、通配符

  1. 泛型在继承方面的体现
    虽然类A是类B的父类，但是G<A>和G<b>二者不具备子父类关系，二者是并列关系。
    补充：类A是类B的父类，则A<G>是B<G>的父类。
  2. 通配符的使用
    通配符：？
    例如：List<?> , Map<?>
    类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
    使用通配符后数据的读取和写入：
      添加（写入）：对于List<?>的对象list，不能向其内部添加数据。因为我们不知道它的元素类型，我们不能向其中添加对象。唯一的例外是null，它是所有类型的成员。
      获取（读取）：读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。

public class GenericTest {

    /*
    1. 泛型在继承方面的体现
    虽然类A是类B的父类，但是G<A>和G<b>二者不具备子父类关系，二者是并列关系。
    补充：类A是类B的父类，则A<G>是B<G>的父类。
     */
    @Test
    public void test1() {

        Object obj = null;
        String str = null;
        obj = str;

        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;

        List<Object> list1 = null;
        List<String> list2 = null;
        //此时的list1和list2的类型不具有子父类关系
        //list1 = list2;  编译不通过
        /*
        反证法：
        假设list1 = list2;
            list1.add(123);  导致混入非String的数据。出错。
         */

        show(list1);
        //show(list2);
    }

    public void show(List<Object> list) { }

    @Test
    public void test2() {

        AbstractList<String> list1 = null;
        List<String> list2 = null;
        ArrayList<String> list3 = null;
        list1 = list3;
        list2 = list3;

        List<String> list4 = new ArrayList<>();
    }

    /*
    2. 通配符的使用
        通配符：？
        类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
     */
    @Test
    public void test3() {
        List<Object> list1 = null;
        List<String> list2 = null;

        List<?> list = null;

        list = list1;
        list = list2;

        print(list1);
        print(list2);
    }

    public void print(List<?> list) {
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
}
  1. 有限制条件的通配符
  • 通配符指定上线：
    上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即小于等于（<=）。
  • 通配符指定下限：
    下限super：使用时指定的类型不能小于操作的类，即大于等于（<=）。
  • 举例：
    – <? extends Number>    —>  (无穷小, Number]
      只允许泛型为Number及Number子类的引用调用
    – <? super Number>    —>  [Number, 无穷大)
      只允许泛型为Number及Number父类的引用调用
    – <? extends Comparable>
      只允许泛型为实现Comparable接口的实现类的引用调用

    public void test4() {

        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List<Student> list3 = new ArrayList<Student>();
        List<Person> list4 = new ArrayList<Person>();;
        List<Object> list5 = new ArrayList<Object>();;

        list1 = list3;
        list1 = list4;
//        list1 = list5;  报错

//        list2 = list3;  报错
        list2 = list4;
        list2 = list5;

        //读取数据：
        list1 = list3;
        Person p = list1.get(0);
        //编译不通过，因为list1为List<? extends Person>，小于等于Person，接收的数据一定是Person的子类，所以要用Person接收数据。
//        Student s = list1.get(0);

        list2 = list4;
        Object obj = list2.get(0);
        //编译不通过，因为list2为List<? super Person>，大于等于Person，接收的数据最小是Person，最大为Object，所以要用Object接收数据。
//        Person person = list2.get(0);

        //写入数据：
        //编译不通过，因为list1为List<? extends Person>，小于等于Person，如果定义的list1的类型比Student还小，那么就会报错。所以不能写入Student的对象。
//        list1.add(new Student());

        //编译通过，因为list2为List<? super Person>，大于等于Person，定义的list2的类型一定比Person大，所以可以写入Person以及Person子类的数据。
        list2.add(new Person());
        list2.add(new Student());
    }
}
Liangxt1997
关注
专栏目录
12_泛型
海涛帅帅的博客
09-14 168
为什么要有泛型 泛型：generic 泛型：标签 举例： 中药店，每个抽屉外面贴着标签 超市购物架上很多瓶子，每个瓶子装的是什么，有标签 泛型的设计背景 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的 对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来 解决。因为这个时候除了元素的类型不确定 ，其他的部分是确定的，例如关于 这个元素如何保存 ，如何管理等是确定的，因此此时把元素的类型设计成一个 参数，这个类型参数叫做泛型。Co
Java泛型的用法及T.class的获取过程解析
08-25
Java泛型的用法及T.class的获取过程解析 Java泛型是Java编程语言中的一种重要特性，它允许开发者在编写代码时指定类型参数，从而提高代码的灵活性和可读性。本文将详细介绍Java泛型的用法 及T.class的获取过程解析...
Java泛型应用实例
01-04
网上很多讲泛型原理的文章, 很少有提到我们什么时候使用泛型有优势, 我就泛型类和方法搞了两个实例,算是探索下泛型使用的冰山一角吧,在我博客里面有配套的文章,可以配套看.
java泛型的简单应用
weixin_44103123的博客
03-10 278
泛型其实质就是将数据的类型参数化。 package testM; import java.util.ArrayList; public class Test1 { public static void main(String[] args) { //ArrayList表示容器的类型、<元素的类型> ArrayList<String> a = new ArrayList<String>(); a.add("string1"); a.add("stri
Java泛型的应用
qq_36556651的博客
06-01 162
一提到泛型，就能想到在集合里的应用，不固定参数的类型，提高类的灵活性。 这里记录下泛型在类、方法和接口上的应用。 泛型类 泛型用在类上如下所示。 public class ObjectTool<T>{ public void show(T t){ System.out.println(t); } } ObjectTool<String> ot=new Object...
什么是泛型
最新发布
weixin_65700815的博客
01-19 945
泛型是Java SE 1.5的新特性，它是一种不确定的数据类型，这种不确定的数据类型需要我们在使用这个类的时候它才能够确定出来，早期的Object类型可以接收任意的对象类型，但是在实际的使用过程当中，会出现类型转换的问题,会报出一个异常，使用泛型就可以避免这种问题，因为泛型可以使编译器在。定义的时候是泛型标识E，在使用的时候给泛型标识定为String类型，编译结束后，进行泛型擦除，生成了class字节码文件，通过反射，此时成员变量key的数据类型就成了Object类型。
Java 泛型总结（一）：基本用法与类型擦除
08-31
"Java 泛型总结（一）：基本用法与类型擦除" Java 泛型是 Java 语言中的一种强大功能，它可以使代码更加简洁、安全。下面是对 Java 泛型的基本用法和类型擦除机制的介绍。 泛型的基本用法 ------------- 泛型是...
java 泛型
04-07
Java泛型是Java编程语言中的一个关键特性，它在2004年随着Java SE 5.0的发布而引入。泛型允许程序员在代码中使用类型参数，从而增加了代码的类型安全性和重用性。它能够帮助我们避免在运行时出现ClassCastException...
详谈Java泛型中T和问号(通配符)的区别
08-28
Java泛型中T和问号(通配符)的区别 Java泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、...
muticollections:Java中的一些muti集合
04-29
1.目的 1. 参看JUC得代码，自己实现一组线程安全的集合工具。 2. 锻炼自己的对Java并发得得认识 2.Start 1. let’s Go.
java中泛型的应用
小嗨嗨的博客
09-27 457
今天跟大家分享一下，java中的泛型机制，在这篇文章介绍了，泛型在接口、类、一般方法、静态方法的实现实例 package interview; /** * @author jing * * 泛型：jdk1.5出现的安全机制。 * 好处： * 1，将运行时期的问题ClassCastException转到了编译时期。 * 2，避免了强制转换的麻烦。 *
泛型在Java中的应用
QQ156881887的专栏
12-08 524
在进行代码编写时，就对对象类型检查，可以减少运行时出现问题的概率。
java泛型应用_Java泛型的应用
weixin_29303701的博客
02-21 309
---恢复内容开始---在开发中，我们有时候会用到泛型来写工具类，为了使方法更通用，以前，没有完全弄懂，今天，就这个机会把泛形写一写泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。泛型的引入，让JAVA更安全。之前没有引入泛型，各种的类型转换错误。泛型的好处是在编...
Java泛型常见应用
OriSu
05-12 245
1.概述 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？ 顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类
java泛型的使用
a107494639的专栏
05-22 940
使用泛型的好处是：在编译的时候检查类型的使用（转化）是否安全，并且所有转化都是自动和隐式的，以及提高了代码重用性。 package org.example.fanxing; /** * DOC 类泛型事例一 * 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。 * * @param */ public class SomeThing { private T
Java泛型的介绍和应用-1
weixin_39158966的博客
04-10 205
泛型是一种可以表示数据类型的 数据类型E 称为泛型泛（广泛）型（类型）===>integer，String，Dog，……泛型又称参数化类型，是jdk5.0出现的新特性，解决数据类型的安全性问题在类声明或者实例化时只要指定好需要的具体类型即可Java泛型可以保证如果程序在编译时没有发出警告，运行就不会产生ClassCastException异常。
什么是Java泛型？泛型在Java中应用场景
2301_77899321的博客
01-15 1566
Java泛型是一种在编译时进行类型检查和类型安全的机制。它允许编写能够操作多种类型的代码，而不需要进行类型转换或使用Object类型。通过在定义类、接口或方法时使用泛型参数，可以使代码更加灵活、可重用和类型安全。
JAVA 泛型中的<T> 和 <?> 的应用场景
Rap的专栏
08-30 2301
在JAVA 泛型中，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值