Java泛型，这个范可真行

已于 2022-08-17 10:40:15 修改
阅读量215 收藏 1
点赞数 3
分类专栏： Java基础 文章标签： java 开发语言 泛型
于 2022-08-17 10:36:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37530429/article/details/126369366
版权

🏀 一、泛型的概念

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

🏄②通俗理解：泛型就是标签！举例：超市中的商品；药店中药盒子上贴的标识。

🏀 二、为何要有泛型

⛳️①解决元素存储的安全性问题。比如商品、药品标签，不会弄错。

⛳️②解决获取数据元素时，需要类型强制转换的问题。比如不用每回拿商品、药品都要辨别。

⛳️③Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，在代码层面上说显得更加简洁、健壮。

🏀 三、集合中使用泛型

🏂①集合接口或集合类在jdk5.0时都修改为带泛型的结构

🏂②在实例化集合类时，可以指明具体的泛型类型

🏂③指明完成以后，在集合类或接口中凡是定义类或接口时，内部结构使用到类的泛型的位置，都指定为实例化的泛型类型

🏂④注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，需要我们拿包装类来进行替换

🏂⑤如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型

🎯如下为集合中使用泛型的实例代码演示：

package com.java.generic;

import com.java.collection.Person;
import org.junit.Test;

import java.util.*;

/**
 * @ClassName: GenericTest
 * @Description:
 * @Author: YuHao
 * @Date: 2022/3/2
 */
public class GenericTest {
    //在集合中使用泛型的情况：以HashMap为实例
    @Test
    public void test3(){
        //jdk7的新特性:类型推断
        Map<String,Integer> map = new HashMap<>();
//        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("Tom",56);
        map.put("Jerry",86);
        map.put("Curry",66);

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

    //在集合中使用泛型的情况：以ArrayList为实例
    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(78);
        list.add(7);
        list.add(8);
        list.add(178);

        //编译时，就会进行类型检查，保证数据的安全
//        list.add("Tom");
        //方式一
        for(Integer score : list){
            //避免了强转操作
            int stuScore = score;
            System.out.println(stuScore);
        }

        //方式二
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            int stuScore = iterator.next();
            System.out.println(stuScore);
        }

    }

    //在集合中使用泛型之前的情况：
    @Test
    public void test1(){
        ArrayList list = new ArrayList();

        //需求：存放各个分数
        list.add(78);
        list.add(7);
        list.add(8);
        list.add(178);

        //问题一：类型不安全
        list.add("Tom");

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

🏀 四、自定义泛型结构

🎾（1）泛型类、泛型接口

🎨①泛型类及泛型接口的的声明
例：interface List 和 Class Demo<K, V>
其中，T，K，V并不代表值，而是表示类型。这里使用任意字母皆可。常用字母T表示，为Type的缩写。

🎨②泛型类及泛型接口的实例化
例：List list = new ArrayList<>( ); Iterator iterator = person.iterator( );
将集合中的内容限制为一个特定的数据类型，即是泛型的核心思想

🎯以下为自定义泛型类的实例代码演示：

package com.java.generic;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: GenericTest1
 * @Description:
 * @Author: YuHao
 * @Date: 2022/3/2
 */
public class GenericTest1 {

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

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<String>("orderAA",1001,"order::aa");
        order1.setOrderT("order:bb");
        System.out.println(order1);
    }

}


package com.java.generic;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: Order
 * @Description: 自定义的泛型类
 * @Author: YuHao
 * @Date: 2022/3/2
 */
public class Order<T> {
    String orderName;
    int orderId;
    //类的内部结构就可以使用类的泛型
    T orderT; //T其实并不是一个类，实际上就是一个参数而已

    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 +
                '}';
    }
}
🎾（2）泛型方法

🎧①泛型方法的格式：
[访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常

🎧②注意项：

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

🎯以下为自定义泛型方法的实例代码演示：

package com.java.generic;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: GenericTest1
 * @Description:
 * @Author: YuHao
 * @Date: 2022/3/2
 */
public class GenericTest1 {
    //测试泛型方法
    @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);
    }
}

package com.java.generic;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: Order
 * @Description: 自定义的泛型方法
 * @Author: YuHao
 * @Date: 2022/3/2
 */
public class Order<T> {
    String orderName;
    int orderId;
    //类的内部结构就可以使用类的泛型
    T orderT; //T其实并不是一个类，实际上就是一个参数而已

    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 static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        //遍历数组，将数组元素加入到list中
        for(E e : arr){
            list.add(e);
        }
        return list;
    }
}

🏀 五、泛型在继承上的体现

🎤①类A是类B的父类，G< A >和G< B > 二者不具备子父类关系，二者是并列关系。

🎤②补充：类A是类B的父类，A< G > B< G >

🎯以下为泛型在继承上的实例代码演示：

package com.java.generic;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: GenericTest1
 * @Description:泛型在继承上的体现
 * @Author: YuHao
 * @Date: 2022/3/2
 */
public class GenericTest1 {
    @Test
    public void test2(){
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
        SubOrder sub1 = new SubOrder();
        sub1.setOrderT(123);
        System.out.println(sub1);

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

package com.java.generic;

/**
 * @ClassName: SubOrder
 * @Description:
 * @Author: YuHao
 * @Date: 2022/3/3
 */
public class SubOrder extends Order<Integer>{//SubOrder不是泛型类,因为已经指明的类参数为Integer，即为普通类

}

package com.java.generic;

/**
 * @ClassName: SubOrder1
 * @Description:
 * @Author: YuHao
 * @Date: 2022/3/3
 */
public class SubOrder1<T> extends Order<T>{ //SubOrder1<T>仍是泛型类，未指明T是什么类型的参数

}

🏀 六、通配符的使用

🎼①通配符：？(就是用疑问号表示通配符)，例如：List<?>，Map<?,?>，List<?>是List< Object >等各种泛型List的父类。

🎼②类A是类B的父类,G< A >和G< B >是没有关系的，二者共同的父类是：G< ? >

🎼③读取：读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。

🎼④写入：写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中添加对象。

🎼⑤有限制条件的通配符：

? extends A :
    G<? extends A> 可以作为G< A > 和 G< B >的父类，其中B是A的子类(小于等于)
? super A :
    G<? super A> 可以作为G<A> 和 G<B>的父类，其中B是A的父类(大于等于)

🎯以下为泛型通配符使用的实例代码演示：

package com.java.generic;

import com.java.collection.Person;
import org.junit.Test;

import java.util.*;

/**
 * @ClassName: GenericTest
 * @Description:
 * @Author: YuHao
 * @Date: 2022/3/2
 */
public class GenericTest {
    /*
    有限制条件的通配符的使用
    ? extends A :
        G<? extends A> 可以作为G<A> 和 G<B>的父类，其中B是A的子类(小于等于)

    ? super A :
        G<? super A> 可以作为G<A> 和 G<B>的父类，其中B是A的父类(大于等于)
     */
    @Test
    public void test7(){

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


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

        //小于等于
        list1 = list4;
        //list1 = list5;

        //大于等于
        list2 = list4;
        list2 = list5;

        //读取数据:
        list1 = list4;
        list1.get(0);
        Person p = list1.get(0);

        //写入数据：
        list2.add(new Person());
    }

    @Test
    public void test6(){
        List<Object> list1 = null;
        List<String> list2 = null;

        List<?> list = null;

        list = list1;
        list = list2;

//        print(list1);
//        print(list2);


        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        list = list3;

        //添加(写入)：对于list<?>就不能向其内部添加数据。
        //除了添加null之外，其他都不能添加
        list.add(null);

        //获取(读取):允许读取数据，读取的数据类型为Object。
        Object o = list.get(0);
        System.out.println(o);
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            Object object = iterator.next();
            System.out.println(object);
        }
    }

    @Test
    public void test5(){
        List<String> list1 = null;
        ArrayList<String> list2 = null;
        AbstractList<String> list3 = null;
        list3 = list2;
        list1 = list2;
    }
}

🍆路过的小伙伴，如果博文有帮助到你解决问题，可以点赞+收藏+关注一波呀~👊👊👊本人将会持续更新相关Java学习的博文，感谢您的支持哦！！！芜湖起飞✈️✈️✈️
在这里插入图片描述

Fish_Vast
关注
专栏目录
Java泛型
sunnyday0426的博客
02-21 1125
Java 泛型泛型概念举个栗子泛型的使用泛型类泛型接口泛型通配符泛型方法泛型方法的基本使用类中的泛型方法泛型方法可变参数静态方法与泛型泛型方法总结泛型上下界结语   同学们，今天我们来一起学习Java中的泛型，泛型在面向对象编程以及各各种设计模式种有非常广泛的应用。 泛型概念   泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。参数化类型就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传
java 泛型 转化对象_java基础之泛型对象与json互转
weixin_34786066的博客
02-16 1782
1. 场景描述把泛型对象转成字符串放到缓存中，获取后使用有点问题，记录下，有碰到的朋友，参考下。2. 解决方案2.1 操作类及说明/*** @auther: 软件老王*/public static void main(String[] args) {VO vo = new VO();UserParm user = new UserParm();user.setUserIdName("1111");...
java 泛型
Misszhoudandan的博客
06-10 1722
泛型就是将数据类型参数化，例如我们实现一个存储对象的容器时，并不是直接定义好只能存储一种类型，好的办法就是定义时将类型参数化，也就是泛型，在真实使用时再传入真正的参数，这种参数化类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
java泛型详解
qq_42003527的博客
08-24 1万+
java泛型详解
java泛型 null_java泛型详解
weixin_29149709的博客
02-24 1111
1. extends与superextends关键字限制了泛型类可以使用的泛型参数类型的上限(Upper Bound)super关键字限制了泛型类可以使用的泛型参数类型的下限(Lower Bound)先定义几个简单的ClassclassFood {}class Fruit extendsFood {}class Meat extendsFood {}class Apple extendsFruit...
Java泛型类
weixin_45710998的博客
12-01 3401
Java泛型类 1. 泛型的概念引入 Java为什么会出现泛型这个规范类。我们就需要知道，为什么Java要引入泛型这个概念。 在JDK1.5中。Java引入了泛型。目的就是解决类型不明确这个问题。我们举个最通俗移动的方式来说明。 我们拿List集合来举例。 我们可以很清楚的看到，List接口后面的 <E> 就属于泛型标识。 我们现在并不知道什么是泛型。我们也不需要关注<E> 他本身是个什么东西。我们在学泛型之前总应该学习了接口吧，学习过集合吧。 呢么我们就可以创建一个ArrayL
Java泛型方法
热门推荐
weixin_45710998的博客
12-02 1万+
Java泛型方法 在学习Java泛型方法之前，我希望你们针对于Java泛型类有一定的了解并且可以熟练的使用。若了解并不是很详细。可以观看我写的另一篇文章 (也是我写的) Java泛型类 来了解一下。 呢么我们速度过一下泛型方法。其实泛型方法并不难理解。 我们直接上代码来演示一下。 首先我们有两个Java类，一个是存在泛型方法的类，一个是Test测试类。名称随便给都可以。 public class Param { public static <T> T param(T t) {
JAVA泛型接口
2301_80884223的博客
06-10 1014
泛型接口：允许在定义接口时声明类型参数，即泛型接口，这种类型参数在整个接口中可当成类型使用。class Sub<具体类型列表>implements IBase<具体类型列表>{}class Sub<类型参数表>implements IBase<类型参数表>{}泛型接口案例：子类Sub实现接口 IBase<T>1.实现子类没有明确地指明类型参数的具体类型。1.泛型的类型参数不能作为静态成员变量的类型。2.静态方法中不能有任何泛型类型参数出现。2.实现子类明确指明类型参数的具体类型。子类实现泛型接口形式。
Java泛型详解
Lov1_BYS的博客
09-25 5296
泛型详解：泛型类、泛型接口、泛型方法、泛型通配符、泛型擦除（桥接方法）、泛型数组、泛型反射...
java泛型
求道问术
11-20 1304
通配符不能添加不能添加不能添加父对象实参类型，形参类型实参不能添加，形参可以添加，产生了二义性，因此实参类型，形参类型实参能添加本类对象，实参能添加子类对象，形参能添加本类对象，形参能添加子类对象。
Java泛型和集合
04-14
[Java泛型和集合].(Java.Generics.and.Collections).Maurice.Naftalin&Philip.Wadler.文字版.pdf
深入Java泛型（五）：Json解析泛型
2401_83916241的博客
04-22 728
经过日积月累， 以下是小编归纳整理的深入了解Java虚拟机文档，希望可以帮助大家过关斩将顺利通过面试。由于整个文档比较全面，内容比较多，篇幅不允许，下面以截图方式展示。由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！存中…(img-CEaI8axI-1713746238872)]
二叉树 java泛型_java二叉树
weixin_36331336的博客
02-13 635
二叉树的非递归遍历二叉树的非递归遍历java的非递归后续遍历文章yichudu2014-04-04791浏览量Java工程师必知词汇：二叉树|名词定义|二叉树(Binary tree)是每个节点最多只有两个分支(即不存在分支度大于2的节点)的树结构。通常分支被称作“左子树”或“右子树”。二叉树的分支具有左右次序，不能随意颠倒。二叉树而言，在进行数据获取的时候也有三种形式：前序遍历(根-左-右)、中...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 297
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Servlet的生命周期
最新发布
wyk的博客
11-13 1038
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
Java基础07
m0_74977981的博客
11-11 692
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 789
Rest请求处理
SpringBoot 实现图片加水印
心猿意码
11-11 394
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 442
顺序算法题----力扣刷题
Java泛型编程指南
"这是一份关于Java泛型的英文自学手册，由Gilad Bracha编写，旨在介绍Java编程语言中的泛型概念。手册包含了多个章节，涵盖了从基础定义到与遗留代码的交互，以及如何将旧代码转换为使用泛型等主题。" Java泛型是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Fish_Vast

您的打赏是对我最大的支持！！！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值