Java 泛型

最新推荐文章于 2024-10-28 20:09:57 发布
最新推荐文章于 2024-10-28 20:09:57 发布
阅读量99 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53605652/article/details/132217898
版权

1 泛型

所谓泛型就是标签，例如中药店的标签 就是允许在定义类、 接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。 这个类型参数将在使用时（例如，继承或实现这个接口， 用这个类型声明变量、 创建对象时） 确定（即传入实际的类型参数， 也称为类型实参）

  • 从JDK1.5以后， Java引入了“ 参数化类型（ Parameterized type）” 的概念，允许我们在创建集合时再指定集合元素的类型， 正如： List， 这表明该List只能保存字符串类型的对象。
  • JDK1.5改写了集合框架中的全部接口和类， 为这些接口、 类增加了泛型支持，从而可以在声明集合变量、 创建集合对象时传入类型实参。
  • 集合没有泛型时：读取出数据需要强制类型转换，有可能抛出ClassCastExceptio
    在这里插入图片描述
  • 集合中使用泛型：可以避免强转，避免抛出ClassCastException
    在这里插入图片描述
    List使用泛型案例
public class ListTest {

    /**
     * 没有泛型
     */
    @Test
    public void test1() {
        List list = new ArrayList();

        list.add(123);//存入 int 装箱 Integer

        String str = (String) list.get(0);//ClassCastException
    }

    /**
     * 使用泛型
     */
    @Test
    public void test2() {
//        List <String> list = new ArrayList<String>();//jdk1.5
        List<String> list = new ArrayList<>();

        list.add("123");//因为泛型，只能存String

        String str = list.get(0);//泛型的主要作用：避免强制类型转换
    }

    /**
     * 泛型list循环
     */
    @Test
    public void test3(){
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        //迭代器循环
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()){
            Integer i = it.next();
            System.out.println(i);
        }

        //增强for循环
        for (Integer i : list) {
            System.out.println(i);
        }

    }

}

Map使用泛型案例

public class MapTest {

    @Test
    public void test1() {
        Map map = new HashMap();

        map.put("a", 111);
        map.put(222, "b");
        map.put(new Date(), "ccc");

        Set set = map.entrySet();
        //EntrySet
        for (Object obj : set) {
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + " " + entry.getValue());
        }

        System.out.println("=================");
        //keySet
        Set keys = map.keySet();
        for (Object obj : keys) {
            System.out.println(obj + " " +map.get(obj));
        }
    }

    @Test
    public void test2(){
    //        Map<String, Integer> map = new HashMap<String, Integer>();
        Map<String,Integer> map = new HashMap<>();

        map.put("a",1);
        map.put("a",1);
        map.put("b",1);
        map.put("c",1);
        map.put("d",1);
        map.put("e",1);
        map.put("f",1);
        map.put("g",1);
        map.put("h",1);



        //EntrySet
        for (Map.Entry<String,Integer> entry : map.entrySet()){
            System.out.println(entry.getKey() + " " + entry.getValue());
        }

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

        //keySet
        Iterator<String> it = map.keySet().iterator();
        while (it.hasNext()){
            String key = it.next();
            System.out.println("key = " + key + "value =" + map.get(key));
        }
    }
}

2 自定义泛型

2.1 泛型类

  • 在类声明时使用泛型约束这个类使用的泛型类型

语法

//格式
public class 类名 <泛型类型1,...> {
    
}

案例

public class GenericsCls<T1, T2> {

    public void f1(T1 arg1, T2 arg2){

        System.out.println(arg1);
        System.out.println(arg2);
    }

    private T1 t1;

    private T2 t2;

    public T1 getT1() {
        return t1;
    }

    public void setT1(T1 t1) {
        this.t1 = t1;
    }

    public T2 getT2() {
        return t2;
    }

    public void setT2(T2 t2) {
        this.t2 = t2;
    }
}

测试

public class Test1 {

    public static void main(String[] args) {
        GenericsCls<String, Date> bean = new GenericsCls<>();
        bean.f1("abc", new Date());

        bean.setT1("t1 = 1");
        bean.setT2(new Date());

        System.out.println(bean.getT1());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(sdf.format(bean.getT2()));

        GenericsCls<String, Clz> bean2 = new GenericsCls<>();
        bean2.f1("aaaa", new Clz());
    }
}

class Clz {
    @Override
    public String toString() {
        return "Clz{}";
    }
}

2.2 泛型方法

语法

public class GenericsMethod {

    /**
     * 泛型方法
     * @param bean
     * @param arg
     * @return
     * @param <T1>
     * @param <T2>
     */

    public static <T1, T2> T1 f1(T1 bean, T2 arg) {
        System.out.println(arg);
        return bean;
    }

    public static void main(String[] args) {
        String str = f1("abc", new Date());

        Date date = f1(new Date(), "cba");

        Integer i = f1(123,"aaa");
    }
}

2.3 泛型接口

例如

public interface GenricsInterface<T>{
    
}

//实现类
public class Clazz implements GenricsInterface<String> {
    
}

案例

public interface GenericsInterface <T>{

    public T getValue();
}

public class IntegerImpl implements GenericsInterface<Integer> {
    @Override
    public Integer getValue() {
        return 123456;
    }
}

public class StringImpl implements GenericsInterface<String>{
    @Override
    public String getValue() {
        return "hello generics interface";
    }
}

测试

public class Test1 {

    public static void main(String[] args) {
        GenericsInterface<String> g1 = new StringImpl();
        System.out.println(g1.getValue());

        GenericsInterface<Integer> g2 = new IntegerImpl();
        System.out.println(g2.getValue());
    }
}

3 泛型通配符

3.1 通配符的上边界

<？ extends T>，在类型参数中使用 extends 表示这个泛型中的参数必须是 T 或者 T 的子类

案例

public class Test1 {

	public static void f1(List<? extends Father> list) {
	    }
	
	public static void main(String[] args) {
	        List<GrandFather> grandFatherList = new ArrayList<>();
	        List<Father> fatherList = new ArrayList<>();
	        List<Monther> montherList = new ArrayList<>();
	        List<Son> sonList = new ArrayList<>();
	        List<Daughter> daughterList = new ArrayList<>();
	
	        f1(sonList);
	        f1(daughterList);
	        f1(fatherList);
	//        f1(grandFatherList);// ? extend Father:表示对象边界是Father和Father的子类
	//        f1(montherList);
	
	        f2(sonList);
	        f2(daughterList);
	        f2(fatherList);
	        f2(grandFatherList);
	        f2(montherList);
	        f2(new ArrayList<String>());
	    }
	
	
	
	    class GrandFather {
	
	    }
	
	    class Father extends GrandFather {
	
	    }
	
	    class Monther {
	        Father father;
	
	    }
	
	    class Daughter extends Father {
	
	    }
	
	    class Son extends Father {
	
	    }
 }

3.2 通配符的下边界

  • ? super Father：Father和father的父类

案例

public class Test2 {


    public static void f1(List<? super Father> list) {

    }

    public static void main(String[] args) {
        List<GrandFather> grandFatherList = new ArrayList<>();
        List<Father> fatherList = new ArrayList<>();
        List<Monther> montherList = new ArrayList<>();
        List<Son> sonList = new ArrayList<>();
        List<Daughter> daughterList = new ArrayList<>();

//        f1(sonList);
//        f1(daughterList);
        f1(fatherList);
        f1(grandFatherList);// ? super Father:表示对象边界是Father和Father的父类
//        f1(montherList);
    }


    class GrandFather {

    }

    class Father extends GrandFather {

    }

    class Monther {
        Father father;

    }

    class Daughter extends Father {

    }

    class Son extends Father {

    }
}

3.3 泛型边界在接口中的应用

  • 声明接口的泛型只能使用T extends Type

案例

public class Test2 {

    class Impl1 implements GenericsInterface<Father>{
        @Override
        public Father getValue() {
            return null;
        }
    }

//    class Impl2 implements GenericsInterface<Monther>{
//        @Override
//        public Monther getValue() {
//            return null;
//        }
//    }
//
//    class Impl3 implements GenericsInterface<String>{
//        @Override
//        public String getValue() {
//            return null;
//        }
//    }
//
//    class Impl4 implements GenericsInterface<GrandFather>{
//        @Override
//        public GrandFather getValue() {
//            return null;
//        }
//    }

    class Impl5 implements GenericsInterface<Son>{
        @Override
        public Son getValue() {
            return null;
        }
    }

    class Impl6 implements GenericsInterface<Daughter>{
        @Override
        public Daughter getValue() {
            return null;
        }
    }


    interface GenericsInterface<T>{
        public T getValue();
    }

    class GrandFather {

    }

    class Father extends GrandFather {

    }

    class Monther {
        Father father;

    }

    class Daughter extends Father {

    }

    class Son extends Father {

    }

}

3.4 无界通配符

  • ?表示传入任意类型

案例

public static void f2(List<?> list){
 }
 
 public void test1(){
        f2(sonList);
        f2(daughterList);
        f2(fatherList);
        f2(grandFatherList);
        f2(montherList);
        f2(new ArrayList<String>());
    }

4 Java的泛型擦除

  • Java的泛型是伪泛型，为什么说Java的泛型是伪泛型呢？因为在编译期间，所有的泛型信息都会被擦除掉，我们常称为泛型擦除。

案例

 @Test
    public void test1(){
        List<String> stringList = new ArrayList<String>();//ArrayList<String>.class
        stringList.add("泛型");
        List<Integer> integerList = new ArrayList<Integer>();//ArrayList.class
        integerList.add(1);
        System.out.println(stringList.getClass());
        System.out.println(stringList.getClass() == integerList.getClass());//ture
    }

结果如下
在这里插入图片描述

四两迷糊
关注
专栏目录
Java泛型
BroRiver
03-26 1356
泛型是一种在编译时实现类型安全的特性，它使得我们可以编写通用的代码，以适用于不同类型的数据。
Java 中的泛型（两万字超全详解）
林二月的博客
08-02 8万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
java 泛型
Misszhoudandan的博客
06-10 1701
泛型就是将数据类型参数化，例如我们实现一个存储对象的容器时，并不是直接定义好只能存储一种类型，好的办法就是定义时将类型参数化，也就是泛型，在真实使用时再传入真正的参数，这种参数化类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 61万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
java泛型
求道问术
11-20 1296
通配符不能添加不能添加不能添加父对象实参类型，形参类型实参不能添加，形参可以添加，产生了二义性，因此实参类型，形参类型实参能添加本类对象，实参能添加子类对象，形参能添加本类对象，形参能添加子类对象。
Java泛型详解
梦想不会灭
05-30 910
一、泛型的本质 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。 二、泛型的作用 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率 1、保证类型的安全性 在没有泛型之前，从集合中
JAVA泛型
weixin_40294256的博客
07-11 1065
java泛型
Java泛型大全
weixin_45203607的博客
10-02 4370
Java泛型大全 1. 概述 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法形参，然后调用此方法时 传递的 实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制
java泛型详解
qq_42003527的博客
08-24 1万+
java泛型详解
JAVA泛型接口
2301_80884223的博客
06-10 928
泛型接口：允许在定义接口时声明类型参数，即泛型接口，这种类型参数在整个接口中可当成类型使用。class Sub<具体类型列表>implements IBase<具体类型列表>{}class Sub<类型参数表>implements IBase<类型参数表>{}泛型接口案例：子类Sub实现接口 IBase<T>1.实现子类没有明确地指明类型参数的具体类型。1.泛型的类型参数不能作为静态成员变量的类型。2.静态方法中不能有任何泛型类型参数出现。2.实现子类明确指明类型参数的具体类型。子类实现泛型接口形式。
Java泛型的用法及T.class的获取过程解析
08-25
Java泛型的用法及T.class的获取过程解析 Java泛型是Java编程语言中的一种重要特性，它允许开发者在编写代码时指定类型参数，从而提高代码的灵活性和可读性。本文将详细介绍Java泛型的用法 及T.class的获取过程解析...
Java 泛型总结（一）：基本用法与类型擦除
08-31
"Java 泛型总结（一）：基本用法与类型擦除" Java 泛型是 Java 语言中的一种强大功能，它可以使代码更加简洁、安全。下面是对 Java 泛型的基本用法和类型擦除机制的介绍。 泛型的基本用法 ------------- 泛型是...
详谈Java泛型中T和问号(通配符)的区别
08-28
Java泛型中T和问号(通配符)的区别 Java泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、...
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 544
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 259
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
最新发布
weixin_44832324的博客
10-28 628
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Spring框架注解开发
2401_85217463的博客
10-23 910
名称：@Component @Controller @Service @Repository类型：类注解位置：类定义上方作用：设置该类为spring管理的bean。
Java泛型编程详解
"Java泛型编程基础" Java泛型是自JDK 1.5版本引入的一种强大的编程特性，它允许在定义类、接口和方法时指定类型参数，从而提高了代码的类型安全性和重用性。泛型的主要目标是增强类型检查，避免在运行时进行强制...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值