【零基础学Java】第二十三篇 泛型

已于 2023-01-10 14:35:35 修改
阅读量156 收藏 1
点赞数 3
分类专栏： Java基础 文章标签： java jvm 开发语言
于 2022-08-27 13:16:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54024106/article/details/126556960
版权

📄个人简介
🔔作者简介：大家好，我是小学生！！🙈大三学生一枚，目前正在自学Java，如果大家觉得我写的还不错的话，希望大家给我点赞👍+收藏⭐+评论📢，有什么写的不对的地方还请大家多多指教🙏，共同进步。
📝个人主页：小学生！！
📖系列专栏
🌕阶段一：Java基础编程
💦目前已原创23篇

🌕阶段二：数据结构与算法
🌕阶段三：操作系统
🌕阶段四：计算机网络

文章目录

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

interface 接口和class 类<K，V>
说明:
1)其中，T,K,V不代表值,而是表示类型。
2)任意字母都可以。常用T表示，是Type的缩写

2.泛型的实例化

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

  1. List strList = new ArrayList0;
  2. Iterator iterator = customers.iterator();
3.泛型使用的注意事项和细节
  1. interface List0 , public class HashSet…等等说明:T,E只能是引用类
  2. 在指定泛型具体类型后，可以传入该类型或者其子类类型
  3. 泛型使用形式List list1 = new ArrayList0);List list2 = new ArrayList<>0);
  4. 如果我们这样写List list3 = new ArrayList();默认给它的泛型是[E就是Object ]。
@SuppressWarnings({"all"})
public class GenericDetail {
    public static void main(String[] args) {
        //1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>(); //OK
        //List<int> list2 = new ArrayList<int>();//错误

        //2. 说明
        //因为 E 指定了 A 类型, 构造器传入了 new A()
        //在给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();
        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();

        //3. 泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        //在实际开发中，我们往往简写
        //编译器会进行类型推断, 推荐使用下面写法
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();

        //4. 如果是这样写 泛型默认是 Object
        ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();

        /*
            public boolean add(Object e) {
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                elementData[size++] = e;
                return true;
            }
         */
        Tiger tiger = new Tiger();
        /*

            class Tiger {//类
                Object e;

                public Tiger() {}

                public Tiger(Object e) {
                    this.e = e;
                }
            }

         */

    }
}
class Tiger<E> {//类
    E e;

    public Tiger() {}

    public Tiger(E e) {
        this.e = e;
    }
}

class A {}
class B extends A {}

class Pig<E> {//
    E e;

    public Pig(E e) {
        this.e = e;
    }

    public void f() {
        System.out.println(e.getClass()); //运行类型
    }
}
3.自定义泛型
1.自定义泛型类

  1. 基本语法
    class类名<T, R.>{成员
    }

  2. 注意细节
    1)普通成员可以使用泛型(属性、方法)

    2)使用泛型的数组，不能初始化

    3)静态方法中不能使用类的泛型

    4)泛型类的类型,是在创建对象时确定的(因为创建对象时，需要指定确定类型)

    5)如果在创建对象时,没有指定类型,默认为Object法的返回值的类型，或者是参数类型。

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

        //T=Double, R=String, M=Integer
        Tiger<Double,String,Integer> g = new Tiger<>("john");
        g.setT(10.9); //OK
        //g.setT("yy"); //错误，类型不对
        System.out.println(g);
        Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
        g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
        System.out.println("g2=" + g2);

    }
}

//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型 (属性、方法)
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型
class Tiger<T, R, M> {
    String name;
    R r; //属性使用到泛型
    M m;
    T t;
    //因为数组在new 不能确定T的类型，就无法在内存开空间
    T[] ts;

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(R r, M m, T t) {//构造器使用泛型

        this.r = r;
        this.m = m;
        this.t = t;
    }

    public Tiger(String name, R r, M m, T t) {//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;
//    public static void m1(M m) {
//
//    }

    //方法使用泛型
    public String getName() {
        return name;
    }

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

    public R getR() {
        return r;
    }

    public void setR(R r) {//方法使用到泛型
        this.r = r;
    }

    public M getM() {//返回类型可以使用泛型.
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}
2.自定义泛型接口

  1. 基本语法
    interface 接口名<T,R…> {}

  2. 注意细节

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

/**
 *  泛型接口使用的说明
 *  1. 接口中，静态成员也不能使用泛型
 *  2. 泛型接口的类型, 在继承接口或者实现接口时确定
 *  3. 没有指定类型，默认为Object
 */

//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {

}
//当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
//，在实现IUsu接口的方法时，使用String替换U, 是Double替换R
class AA implements IA {

    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {

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

    }
}

//实现接口时，直接指定泛型接口的类型
//给U 指定Integer 给 R 指定了 Float
//所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
class BB implements IUsb<Integer, Float> {

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

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

    }
}
//没有指定类型，默认为Object
//建议直接写成 IUsb<Object,Object>
class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {
    }
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }

}

interface IUsb<U, R> {

    int n = 10;
    //U 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;
    }
}
3.自定义泛型方法
  1. 基本语法
    修饰符<T,R…返回类型方法名(参数列表){}
  2. 注意细节
    1.泛型方法,可以定义在普通类中,也可以定义在泛型类中
    2.当泛型方法被调用时,类型会确定
    3.public void eat(E e)0，修饰符后没有<T,R…> eat方法不是泛型方法,而是使用了泛型。
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
        System.out.println("=======");
        car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型

        //测试
        //T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}

//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类

    public void run() {//普通方法
    }
    //说明 泛型方法
    //1. <T,R> 就是泛型
    //2. 是提供给 fly使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}

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

    }
    //说明
    //1. 下面hi方法不是泛型方法
    //2. 是hi方法使用了类声明的 泛型
    public void hi(T t) {
    }
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }

}
4.泛型的继承和通配符

1)泛型不具备继承性

2)<?>︰支持任意泛型类型

3)<? extends A>:支持A类以及A类的子类,规定了泛型的上限

4)<? super A>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

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

        Object o = new String("xx");

        //泛型没有继承性
        //List<Object> list = new ArrayList<String>();

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是 List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
        //printCollection2(list1);//×
        //printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×


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

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

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

}

class AA {
}

class BB extends AA {
}

class CC extends BB {
}
小学生！！
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
自定义泛型
lidong777777的博客
08-02 100
本次博客带领大家学习自定义泛型，了解自定义泛型类、接口和方法等等。
java 泛型默认_Java泛型的使用
weixin_31444171的博客
02-16 826
泛型的定义：泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时(例如，继承或实现这个接口，用这个类型声明变量、创建对象时)确定(即传入实 际的类型参数，也称为类型实参)。泛型的引入背景：集合容器类在设计阶段或声明阶段不能确定这个容器到底实际存储的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1....
Java基础学习——第十二章 泛型
weixin_47392089的博客
04-11 375
Java基础学习——第十二章 泛型 一、泛型的概念 1. 泛型的设计背景 集合容器类在声明阶段无法确定实际存储的是什么类型的对象，故JDK5.0之前只能把元素类型声明为Object JDK1.5之后使用泛型来解决：由于此时除了元素的类型不确定之外，其他的部分都是确定的， 例如关于这个元素如何保存， 如何管理等。因此把元素的类型设计成一个参数， 这种参数化类型的概念就是泛型 Collection<E>， List<E>， ArrayList<E> 中的<E>
【Java基础系列教程】第十八章 Java泛型详解
波哩个波的博客
03-09 528
一、泛型概述 二、简单示例解析概念 三、类型擦除 四、自定义泛型结构 五、泛型在继承上的体现 六、通配符的使用 七、泛型应用举例 八、面试题
JAVA 基础(第二十天) 泛型 Collection List Set
qq_55624813的博客
11-14 967
目录 集合 1 Collection接口 1.1 集合前言 1.2 集合概念 1.3 集合的继承结构 1.4 Collection方法速查表 1.5 练习:Collection接口测试 2 泛型 2.1 概念 2.2 作用 2.3 泛型示例 2.4 泛型声明 2.5 常用名称 2.6 练习:泛型测试 2.7 练习:泛型测试2 3 List接口 3.1 概述 3.2 特点 3.3 List方法速查表 3.4 练习:List接口测试 3.5 练习:List接口测试2 .
java 泛型转换_Java总结篇系列：Java泛型（转）
weixin_39524183的博客
02-12 1363
一. 泛型概念的提出(为什么需要泛型)？首先，我们看下下面这段简短的代码:1 public classGenericTest {23 public static voidmain(String[] args) {4 List list = newArrayList();5 list.add("qqyumidi");6 list.add("co...
学习java的第三十天，泛型、Set子接口的学习
10719876
07-01 124
学习java的第三十天，泛型、Set子接口的学习
Java学习第十二章——泛型
u014681502的博客
07-02 285
泛型概述 泛型的使用 1.jdk 5.0新增的特性 2.在集合中使用泛型： 总结： ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。 ② 在实例化集合类时，可以指明具体的泛型类型 ③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置， 都指定为实例化的泛型类型。 比如：add(E e) --->实例化以后：add(Integer e) ④ 注意点：泛型的类型必须是类，不能是基...
Java基础篇泛型补充
weixin_44606952的博客
05-16 153
CSDN话题挑战赛第1期 活动详情地址：https://marketing.csdn.net/p/bb5081d88a77db8d6ef45bb7b6ef3d7f 参赛话题：Java学习记录 话题描述：可以记录一下平时学习Java中的一些知识点、心得、例题、常见的问题解决 说明 泛型重要的知识点就在于对集合中泛型的使用，以及在开发时中实现对数据库的操作，其他的细小知识点理解即可,不必深究 代码目录1.1 泛型在继承上的使用1.2 泛型在开发中的使用举例1.3 泛型使用示例 1.1 泛型在继承上的使用
java语言程序设计基础篇第十版第十三章练习标准答案.pdf
10-12
Java 语言程序设计基础篇第十三章练习标准答案 本资源提供了 Java 语言程序设计基础篇第十三章的练习标准答案，包括三个练习题的解决方案。这些练习题涵盖了 Java 语言的多个方面，例如面向对象编程、泛型、集合...
Java语言程序设计基础篇
01-04
《Java语言程序设计基础篇》是一本全面介绍Java编程基础知识的教材，由知名教育家梁勇编著。这本书涵盖了从入门到进阶的多个主题，旨在帮助初学者掌握Java编程的核心概念和技术。根据提供的文件名，我们可以推断出...
java语言程序设计基础篇英文8版课后习题答案
11-03
Java语言程序设计基础篇是学习Java编程的入门教材，第8版提供了丰富的学习材料和练习题，旨在帮助初学者掌握编程基础。这份压缩包包含了该书的英文版部分课后习题答案，特别是编程题的解答，对于自我检验和深入理解...
java核心基础,适合自学，以及由基础的学习
09-02
2. **第二章：语法基础** - 包括数据类型（如整型、浮点型、字符型和布尔型）、变量、运算符、流程控制语句（如if、switch、for、while）等，这些都是编写任何程序的基础。 3. **第三章：类与对象** - Java是面向...
Java学习资料.zip
02-03
4. **数组**：Java中的数组是同类型元素的集合，可以是一维、二维或多维。 5. **字符串**：String类在Java中扮演重要角色，理解其不可变性以及常用方法如substring、indexOf等。 接下来，深入到面向对象的编程概念...
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 325
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
（javaweb）请求响应postman
2301_79144798的博客
08-08 477
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 264
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 229
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Java核心技术第8版：基础篇详解
第十三章讲解了泛型程序设计，这是Java SE 5引入的一项重要改进，有助于提高代码的类型安全性和可重用性。最后一章则围绕集合框架展开，这是数据存储和操作的基础，而多线程则是第十四章的核心内容，帮助读者理解...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小学生！！

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值