第十二章 泛型

最新推荐文章于 2022-07-12 22:42:19 发布
最新推荐文章于 2022-07-12 22:42:19 发布
阅读量185 收藏
点赞数
分类专栏： # javaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42082278/article/details/107617391
版权

目录

一、为什么要有泛型

  • 泛型：标签
  • 举例：
    中药店，每个抽屉外面贴着标签
    超市购物架上很多瓶子，每个瓶子装的是什么，有标签
  • 泛型的设计背景
    集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就是类型参数，即泛型。

泛型的概念

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

那么为什么要有泛型呢，直接Object不是也可以存储数据吗？

  1. 解决元素存储的安全性问题，好比商品、药品标签，不会弄错。
  2. 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别。

有没有泛型的对比

在这里插入图片描述
在这里插入图片描述

二、在集合中使用泛型

ArrayList<Integer> list = new ArrayList<>();//类型推断
	list.add(78);
	list.add(88);
	list.add(77);
	list.add(66);
	//遍历方式一：
	//for(Integer i : list){
	//不需要强转
	//System.out.println(i);
	//}
	//遍历方式二：
	Iterator<Integer> iterator = list.iterator();
	while(iterator.hasNext()){
	System.out.println(iterator.next());
}



Map<String,Integer> map = new HashMap<String,Integer>();
	map.put("Tom1",34);
	map.put("Tom2",44);
	map.put("Tom3",33);
	map.put("Tom4",32);
	//添加失败
	//map.put(33, "Tom");
	Set<Entry<String,Integer>> entrySet = map.entrySet();
	Iterator<Entry<String,Integer>> iterator = entrySet.iterator();
	while(iterator.hasNext()){
	Entry<String,Integer> entry = iterator.next();
	System.out.println(entry.getKey() + "--->" + entry.getValue());
}

三、自定义泛型结构

自定义泛型结构

  1. 泛型的声明
    interface List 和 class GenTest<K,V>
    其中，T,K,V不代表值，而是表示类型。这里使用任意字母都可以。
    常用T表示，是Type的缩写。

  2. 泛型的实例化：

  • 一定要在类名后面指定类型参数的值（类型）。如：
    List strList = new ArrayList();
    Iterator iterator = customers.iterator();
  • T只能是类，不能用基本数据类型填充。但可以使用包装类填充
  • 把一个集合中的内容限制为一个特定的数据类型，这就是generics背后
    的核心思想

在这里插入图片描述

自定义泛型结构：泛型类、泛型接口

  1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：
    <E1,E2,E3>
  2. 泛型类的构造器如下：public GenericClass(){}。
    而下面是错误的：public GenericClass(){}
  3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
  4. 泛型不同的引用不能相互赋值。

尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有
一个ArrayList被加载到JVM中。

  1. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价
    于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
  2. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
  3. jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
  4. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
class GenericTest {
	public static void main(String[] args) {
	// 1、使用时：类似于Object，不等同于Object
	ArrayList list = new ArrayList();
	// list.add(new Date());//有风险
	list.add("hello");
	test(list);// 泛型擦除，编译不会类型检查
	// ArrayList<Object> list2 = new ArrayList<Object>();
	// test(list2);//一旦指定Object，编译会类型检查，必须按照Object处理
}
public static void test(ArrayList<String> list) {
	String str = "";
	for (String s : list) {
	str += s + ","; }
	System.out.println("元素:" + str);
	} 
}
  1. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态
    属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法
    中不能使用类的泛型。
  2. 异常类不能是泛型的
  3. 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];
    参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
    12.父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

子类不保留父类的泛型：按需实现
没有类型 擦除
具体类型
子类保留父类的泛型：泛型子类
全部保留
部分保留

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

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{//等价于class Son extends Father<Object,Object>{
}
// 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> {
}


class Person<T> {
// 使用T类型定义变量
private T info;
// 使用T类型定义一般方法
public T getInfo() {
return info; }
public void setInfo(T info) {
this.info = info; }
// 使用T类型定义构造器
public Person() {
}
public Person(T info) {
this.info = info; }
// static的方法中不能声明泛型
//public static void show(T t) {
//
//}
// 不能在try-catch中使用泛型定义
//public void test() {
//try {
//
//} catch (MyException<T> ex) {
//
//}
//}
}

自定义泛型结构：泛型方法

  • 方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型
    方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
  • 泛型方法的格式：
    [访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
  • 泛型方法声明泛型时也可以指定上限(在12.5中讲)
    在这里插入图片描述

public static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
for (T o : a) {
c.add(o);
} }
public static void main(String[] args) {
Object[] ao = new Object[100];
Collection<Object> co = new ArrayList<Object>();
fromArrayToCollection(ao, co);
String[] sa = new String[20];
Collection<String> cs = new ArrayList<>();
fromArrayToCollection(sa, cs);
Collection<Double> cd = new ArrayList<>();
// 下面代码中T是Double类，但sa是String类型，编译错误。
// fromArrayToCollection(sa, cd);
// 下面代码中T是Object类型，sa是String类型，可以赋值成功。
fromArrayToCollection(sa, co);
}



class Creature{}
class Person extends Creature{}
class Man extends Person{}
class PersonTest {
public static <T extends Person> void test(T t){
System.out.println(t);
}
public static void main(String[] args) {
test(new Person());
test(new Man());
//The method test(T) in the type PersonTest is not 
//applicable for the arguments (Creature)
test(new Creature());
} }

四、泛型在继承上的体现

  • 请输出如下来两段代码有何不同
    在这里插入图片描述
    在这里插入图片描述

public void testGenericAndSubClass() {
Person[] persons = null;
Man[] mans = null;
// 而 Person[] 是 Man[] 的父类.
persons = mans;
Person p = mans[0];
// 在泛型的集合上
List<Person> personList = null;
List<Man> manList = null;
// personList = manList;(报错) }

五、通配符的使用

  1. 使用类型通配符：？
    比如：List<?> ，Map<?,?>
    List<?>是List、List等各种泛型List的父类。
  2. 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型
    是什么，它包含的都是Object。
  3. 写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中
    添加对象。
    唯一的例外是null，它是所有类型的成员
  • 将任意元素加入到其中不是类型安全的：

Collection<?> c = new ArrayList();
c.add(new Object()); // 编译时错误
因为我们不知道c的元素类型，我们不能向其中添加对象。add方法有类型参数E作为集
合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知
道那是什么类型，所以我们无法传任何东西进去。

  • 唯一的例外的是null，它是所有类型的成员。
  • 另一方面，我们可以调用get()方法并使用其返回值。返回值是一个未知的类型，但是我们知道，它总是一个Object。
public static void main(String[] args) {
List<?> list = null;
list = new ArrayList<String>();
list = new ArrayList<Double>();
// list.add(3);//编译不通过
list.add(null);
List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
l1.add("尚硅谷");
l2.add(15);
read(l1);
read(l2);
}
public static void read(List<?> list) {
for (Object o : list) {
System.out.println(o);
} }

通配符的使用：注意点

在这里插入图片描述

有限制的通配符

  • <?>

    允许所有泛型的引用调用

  • 通配符指定上限
    上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=

  • 通配符指定下限
    下限super：使用时指定的类型不能小于操作的类，即>=

  • 举例：

  1. <? extends Number> (无穷小 , Number] 只允许泛型为Number及Number子类的引用调用
  2. <? super Number> [Number , 无穷大) 只允许泛型为Number及Number父类的引用调用
  3. <? extends Comparable>只允许泛型为实现Comparable接口的实现类的引用调用 
public static void printCollection3(Collection<? extends Person> coll) {
//Iterator只能用Iterator<?>或Iterator<? extends Person>.why?
Iterator<?> iterator = coll.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
} }
public static void printCollection4(Collection<? super Person> coll) {
//Iterator只能用Iterator<?>或Iterator<? super Person>.why?
Iterator<?> iterator = coll.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
} }

练习

在这里插入图片描述

六、泛型应用举例

泛型嵌套

public static void main(String[] args) {
HashMap<String, ArrayList<Citizen>> map = new HashMap<String, ArrayList<Citizen>>();
ArrayList<Citizen> list = new ArrayList<Citizen>();
list.add(new Citizen("刘恺威"));
list.add(new Citizen("杨幂"));
list.add(new Citizen("小糯米"));
map.put("刘恺威", list);
Set<Entry<String, ArrayList<Citizen>>> entrySet = map.entrySet();
Iterator<Entry<String, ArrayList<Citizen>>> iterator = entrySet.iterator();
while (iterator.hasNext()) {
Entry<String, ArrayList<Citizen>> entry = iterator.next();
String key = entry.getKey();
ArrayList<Citizen> value = entry.getValue();
System.out.println("户主：" + key);
System.out.println("家庭成员：" + value);
} 
}

实际案例

用户在设计类的时候往往会使用类的关联关系，例如，一个人中可以定义一个信息
的属性，但是一个人可能有各种各样的信息（如联系方式、基本信息等），所以此信
息属性的类型就可以通过泛型进行声明，然后只要设计相应的信息类即可。

在这里插入图片描述

坐在西半球上
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java泛型—全教程（官方原版）
深圳市多克创新科技有限公司
03-20 595
Java泛型—全教程（官方原版）
java教程——泛型
m0_64867435的博客
12-05 108
问题二：我们往 add() 方法里改传 selfMap 可以吗？ 解：肯定是不可以的，我们在 java教程——泛型（一）中的 向上转型 的时候说过 selfMap 不是 selfMap 的子类，所以，报错是可想而知的。 当 selfMap 作为函数参数时，该如何传一个 selfMap 呢？ 这个时候 extends通配符 就起作用了，我们可以这么写，代码如下： package test; import java.lang.reflect.Field; i.
Java泛型
Java721的博客
07-01 212
文章目录泛型什么是泛型向上转型小结使用泛型泛型接口小结编写泛型静态方法多个泛型类型小结擦拭法不恰当的覆写方法泛型继承小结extends通配符extends通配符的作用使用extends限定T类型小结super通配符对比extends和super通配符PECS原则无限定通配符小结泛型和反射谨慎使用泛型可变参数小结 泛型 泛型是一种“代码模板”，可以用一套代码套用各种类型 什么是泛型 在讲解什么是泛型之前，我们先观察Java标准库提供的ArrayList，它可以看作是”可变长度“的数组，因为用起来比数组更方便。
java - 泛型，extends通配符，super通配符，泛型和反射
zzqtty的博客
04-15 365
目录 泛型 什么是泛型 向上转型 小结 擦拭法 不恰当的覆写方法 泛型继承 小结 extends通配符 extends通配符的作用 使用extends限定T类型 小结 super通配符 对比extends和super通配符 PECS原则 无限定通配符 小结 泛型和反射 谨慎使用泛型可变参数 小结 泛型 泛型是一种“代码模板”，可以用一套代码套用各种类型。 什么是泛型 在讲解什么是泛型之前，我们先观察Java标准库提供的ArrayList，它可以看作“.
Java学习笔记——泛型
m0_67198282的博客
07-12 134
泛型
第12章 泛型1
08-08
第12章 泛型12.1 泛型的概念12.1.1 没有泛型的麻烦举例：下面有四个瓶子，准备用来装“醋”、“酱油”、“黄酒”、“花椒油”，如果瓶子没有标签的话，那么
06_第6章 泛型与集合1
08-03
第六章泛型与集合Ø 理解Java集合框架的结构Ø 掌握Java迭代器接口的使用Ø 掌握List结构集合类的使用Ø 掌握Set结构集合类的使用Ø 掌握Map结构集
尚硅谷_宋红康_第12章_泛型.pdf
07-05
·自Java语言起源始，循序渐进，知识点剖析细致且每章配备大量随堂练习，让你步步为营，学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千...
JAVA语言与编程第7章容器和泛型.ppt
09-28
JAVA语言与编程第7章容器和泛型.ppt
Java SE完整版精品优质课件 自学入门必看的优秀Java基础知识培训教案 第08章_泛型(共22页).pptx
08-29
Java SE完整版精品优质课件 自学入门必看的优秀Java基础知识培训教案 特别适合新入门自学的新手同学，也适合老手回顾学习，巩固知识 第1章 Java语言概述 ...第12章 Java常用类 第13章 Java反射 第14章 网络编程
黑马程序员——泛型
youngheiying的博客
10-13 302
------- android培训、java培训、期待与您交流！ ---------- 一、概述 1、JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。 2、格式： 通过 如：ArrayList  //定义要存入集合中的元素指定为String类型 3、JDK1.5的集合类希望在定义集合时，明确表明你要向集
Java基础篇：泛型
HTZW的博客
04-25 214
文章目录1、为什么要有泛型2、在集合中使用泛型3、自定义泛型结构4、泛型在继承上的体现5、通配符的使用 1、为什么要有泛型 泛型：标签 泛型的设计背景 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存...
public <T> void method，此地泛型的意思
weixin_33875839的博客
09-19 495
2019独角兽企业重金招聘Python工程师标准>>> ...
Java(老白再次入门) - 泛型
Syntactic Sugar
06-09 226
本系列文章均为尚硅谷资源！如有侵权，我将立即删除！ Java基础知识图解 1.为什么要有泛型 泛型的设计背景 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。 因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就是类型参数.
Java泛型笔记一
IAMLSL的博客
02-01 793
12-1 泛型(Generic)概述 一、泛型（可理解为标签） 举例： 中药店，每个抽屉外面贴着标签 超市购物架上很多瓶子，每个瓶子装的是什么，有标签。 二、泛型的设计背景 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以 在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Co...
【Java 16】泛型 - 集合中使用泛型、自定义泛型结构、泛型在继承上的体现、通配符
Wmiao
08-31 328
泛型泛型1 为什么要有泛型2 在集合中使用泛型3 自定义泛型3.1 泛型类、泛型接口3.2 泛型方法4 泛型在继承上的体现5 通配符的使用5.1 使用5.2 使用注意点5.3 有限制的通配符5.3.1 简述5.3.2 练习题6 泛型应用举例7 自定义泛型类的使用 泛型 1 为什么要有泛型 2 在集合中使用泛型 ArrayList<Integer> list = new ArrayList<>();//jdk7新特性， 类型推断 list.add(78); list.add
第五章 面向对象（中）
qq_42082278的博客
07-09 665
一、OOP特征二：继承性 二、方法的重写(override) 三、四种访问权限修饰符 四、关键字：super 五、 子类对象实例化过程 六、OOP特征三：多态性 七、Object类的使用 八、包装类的使用
第二章 java基本语法
qq_42082278的博客
06-30 623
第一部分
泛型
最新发布
05-26
泛型（Generics）指的是一种编程语言的特性，它允许在编译时期对代码中的类型进行参数化，从而实现更加抽象化和通用化的代码。在一个泛型类或方法中，某些类型可以在定义时被指定为参数，而在实际使用时再进行具体的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值