【11章Java泛型】全面解读Java泛型

❤写在前面
❤博客主页：努力的小鳴人
❤系列专栏：JavaSE超详总结😋
❤欢迎小伙伴们，点赞👍关注🔎收藏🍔一起学习！
❤如有错误的地方，还请小伙伴们指正！🌹

---

一、为什么要有泛型？

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

1. 解决元素存储的安全性问题，好比商品、药品标签，不会弄错
2. 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别
3. 概念：
   标签
   ●允许在定义类、接口时通过一个标识表示类中某个属性的类型或是某个方法的返回值及参数类型
   ●将在使用时确定（例：继承或实现这个接口，用这个类型声明变量、创建对象时）
4. 泛型的设计背景
   集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，JDK1.5之后使用泛型来解决，因为这个时候除了元素的类型不确定，其他部分是确定的，例关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型
   Collection，List，ArrayList 这个就是类型参数(泛型)

🎁注：Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常，同时代码更加简洁、健壮

二、集合中使用泛型

上代码：

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背后的核心思想

JDK 1.5 之前

Comparable c = new Date();
System.out.println(c.compareTo("red"));

JDK 1.5后

Comparable<Date> c = new Date();
System.out.println(c.compareTo("red"));

使用泛型的主要优点是 能够在编译时而不是在运行时检测错误

3. 异常类不能是泛型
4. 在类/接口上声明的泛型
   ●可以作为非静态属性的类型、参数类型、返回值类型
   ●可以在静态方法中不能使用类的泛型
5. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
   ●子类不保留父类的泛型：按需实现
     没有类型 擦除
     具体类型
   ●子类保留父类的泛型：泛型子类
     全部保留
     部分保留
   一句话总结：子类除了指定或保留父类的泛型，还可以增加自己的泛型

🔥自定义泛型类、接口

1. 泛型类可能有多个参数，例：<E1,E2,E3>
2. 泛型类的构造器如下：public GenericClass(){ }
3. 泛型不同的引用不能相互赋值
   例：尽管在编译时ArrayList和ArrayList是两种类型，但在运行时只有一类ArrayList被加载到JVM中
4. 若泛型结构是一个抽象类或接口，则不可创建泛型类的对象
5. jdk1.7之后，泛型的简化操作：ArrayList flist = new ArrayList<>();

class GenericTest {
	public static void main(String[] args) {
		// 使用时：类似于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);
	}
}

泛型类

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;
}

🔥自定义泛型方法

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

public class DAO {
	public <E> E get(int id, E e) {
		E result = null;
		return result;
	}
}

四、泛型在继承上的说明

如果B是A的一个子类型（子类或者子接口）而G是具有泛型声明的类或接口，G$<B>$并不是G$<A>$的子类型
例如：String是Object的子类，但是List$<String>$并不是List$<Object>$的子类

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<$String$>、List<$Object$>等各种泛型 List的父类
2. 读取List<?>的对象list中的元素是绝对安全的，因为它包含的都是Object
3. 写入list中的元素时，我们不知道c的元素类型，我们不能向其中添加
     唯一的例外是null，它是所有类型的成员

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);
	}
}

🔥通配符使用注意点

1、 编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
public static <?> void test(ArrayList<?> list){

}
2、 编译错误：不能用在泛型类的声明上
class GenericTypeClass<?>{

}
3、 编译错误：不能用在创建对象上，右边属于创建集合对象
ArrayList<?> list2 = new ArrayList<?>();

🔥有限制的通配符

1. 通配符指定上限：extends：<=
   使用时指定的类型必须是继承某个类或实现某个接口
2. 通配符指定下限：super：>=
   使用时指定的类型不能小于操作的类
3. 举例：
   ●<? extends Number> (无穷小 , Number]
    只允许泛型为Number及Number子类的引用调用
   ●<? super Number> [Number , 无穷大)
    只允许泛型为Number及Number父类的引用调用
   ●<? 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());
	}
}

🎁总结：泛型，类型的参数化，泛型方法可以说是极其好用的工具
👌 作者算是一名Java初学者，文章如有错误，欢迎评论私信指正，一起学习~~
😊如果文章对小伙伴们来说有用的话，点赞👍关注🔎收藏🍔就是我的最大动力！
🚩不积跬步，无以至千里，书接下回，欢迎再见🌹