图文详解 Java 泛型
泛型—— 一种可以接收数据类型的数据类型，本文将通俗讲解Java泛型的优点、方法及相关细节。
一、泛型的引入
我们都知道，继承是面向对象的三大特性之一，比如在我们向集合中添加元素的过程中add()方法里填入的是Object类，而Object又是所有类的父类，这就产生了一个问题——添加的类型无法做到统一 由此就可能产生在遍历集合取出元素时类型不统一而报错问题。
例如：我向一个ArrayList集合中添加Person类的对象，但是不小心手贱添加了一个Boy类的对象，这就会导致如下结果
图片
传统的方式不能对加入到集合ArrayList中的数据类型进行约束(不安全)遍历的时候，需要进行类型转换,如果集合中的数据量较大，对效率有影响 这就极大地降低了程序的健壮性，因此设计者针对此问题引入了泛型！
二、使用泛型的好处
1.提升了程序的健壮性和规范性
针对上述问题，当我们采用泛型就会显得非常简单，只需要在编译类型后利用泛型指定一个特定类型，编译器就会自动检测出不符合规范的类并抛出错误提示
图片
2.编译时,检查添加元素的类型，提高了安全性
3.减少了类型转换的次数,提高效率
- 当不使用泛型时：
图片
- 当使用泛型时：
图片
4.在类声明时通过一个标识可以表示属性类型、方法的返回值类型、参数类型
class Person<E> {
E s; //可以是属性类型
public Person(E s) { //可以是参数类型
this.s = s;
}
public E f() { //可以是返回类型
return s;
}
public void show() {
System.out.println(s.getClass()); //显示S的运行类型
}
}
可以这样理解：上述的class Person< E >中的“E”相当于这里的E是一个躯壳 占位用的 以后定义的时候程序员可以自己去自定义。
就像这样
public static void main(String[] args) {
Person<String> person1 = new Person<String>("xxxx");// E->String
person.show();
Person<Integer> person2 = new Person<Integer>(123); // E->Integer
person.show();
}
运行结果：
class java.lang.String
class java.lang.Integer
三、泛型常见用法
1.定义泛型接口
曾经写接口的时候都没有定义泛型，它默认的就是Object类，其实这样写是不规范的！
如果说接口的存在是一种规范，那泛型接口就是规范中的规范
interface Im<U,R>{
void hi(R r);
void hello(R r1,R r2,U u1,U u2);
default R method(U u){
return null;
}
}
在上述的泛型接口中已经规定传入其中的必须是U，R类的对象，那么当我们传入其他类的对象时就会报错，如图：
图片
根据规则，当我们实现接口时，就必须实现他的所有方法，而在这时我们就可以向<U,R>中传入我们自己规定的类。在IDEA中重写接口中的方法时，编译器会自动将<U,R>替换成我们事先规定的类。
2.定义泛型集合
1.使用泛型方式给HashSet中放入三个学生对象，并输出对象信息
HashSet<Student> students = new HashSet<Student>();
students.add(new Student("懒羊羊",21));
students.add(new Student("喜羊羊",41));
students.add(new Student("美羊羊",13));
for (Student student :students) {
System.out.println(student);
}
上述的 泛型中Student的是我事先定义好的一个类，把它放到其中作为泛型来约束传入的对象，以及在遍历时减少转型的次数提高效率
2.使用泛型方式给HashMap中放入三个学生对象，并输出对象信息
HashMap<String, Student> hm = new HashMap<String, Student>();
// K-> String V->Student与下面的对应
hm.put("001",new Student("喜羊羊",21));
hm.put("002",new Student("懒羊羊",32));
hm.put("003",new Student("美羊羊",43));
Set<Map.Entry<String,Student>> ek=hm.entrySet();
Iterator<Map.Entry<String, Student>> iterator = ek.iterator();//取出迭代器
while (iterator.hasNext()) {
Map.Entry<String, Student> next = iterator.next();
System.out.println(next.getKey()+" - "+next.getValue());
}
[HashMap是一个双列集合，以K-V]的方式存储对象，因此在使用泛型时要向其中传入两个类型
我们都知道使用迭代器遍历HashMap时要先通过
entrySet()取出键值对，然后通过转型得到对应的类来得到对象信息。而在使用泛型定义[K-V]就规定了取出的键值对的类型，所以就省去了转型这一步骤，同样也使程序变得简单，高效。
四、泛型使用细节
1.<>中类型规范
图片
2.继承性体现
在给泛型指定具体类型后，可以传入该类型或者其子类类型
P<A> ap = new P<A>(new A());
P<A> ap1 = new P<A>(new B()); //A的子类
class A {}
class B extends A{}
3.简写形式
P<A> ap = new P(new A());
五.泛型的定义与使用
我们在集合中会大量使用泛型，这里来完整地学习泛型知识。
泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
1.定义和使用含有泛型的类
定义格式：
修饰符 class 类名<代表泛型的变量,E,未知类型> { }//E未知类型写在类里面,当创建这个类的对象的时候指定具体的类型,比如String,理解E=String;
例如，API中的ArrayList集合：定义一个泛型,写一个泛型↓
class ArrayList<E>{ //<E>定义一个泛型,写一个泛型,未知的类型(通用类型),使用泛型就是给E变量进行赋值(创建类的而对象的时候指定)
public boolean add(E e){ }
public E get(int index){ }
....
}
使用泛型： 即什么时候确定泛型。
在创建对象的时候确定泛型↑
例如，ArrayList<String> list = new ArrayList<String>();//使用泛型,确定泛型
此时，变量E的值就是String类型,那么我们的类型就可以理解为：
class ArrayList<String>{
public boolean add(String e){ }
public String get(int index){ }
...
}
再例如，ArrayList<Integer> list = new ArrayList<Integer>();
此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：
class ArrayList<Integer> {
public boolean add(Integer e) { }
public Integer get(int index) { }
...
}
举例自定义泛型类
public class MyGenericClass<MVP> {//MVP未知类型,赋值具体类型
//没有MVP类型，在这里代表 未知的一种数据类型 未来赋值传递什么就是什么类型
private MVP mvp;
public void setMVP(MVP mvp) {
this.mvp = mvp;
}
public MVP getMVP() {
return mvp;
}
}
使用:
public class GenericClassDemo {
public static void main(String[] args) {
// 创建一个泛型为String的类
MyGenericClass<String> my = new MyGenericClass<String>();
// 调用setMVP
my.setMVP("大胡子登登");
// 调用getMVP
String mvp = my.getMVP();
System.out.println(mvp);
//创建一个泛型为Integer的类
MyGenericClass<Integer> my2 = new MyGenericClass<Integer>();
my2.setMVP(123);
Integer mvp2 = my2.getMVP();
}
}
2.含有泛型的方法
定义格式：
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }//巧记,中间插入尖括号<>
例如，
public class MyGenericMethod {
public <MVP> void show(MVP mvp) {
System.out.println(mvp.getClass());
}
public <MVP> MVP show2(MVP mvp) {
return mvp;
}
//扩展,静态怎么写
public static <MVP> void show3(MVP mvp) {//MVP未知类型泛型<变量>,mvp="lshuhao";String
System.out.println(mvp);
}
}
使用格式：调用方法时，确定泛型的具体类型
public class GenericMethodDemo {
public static void main(String[] args) {
// 创建对象
MyGenericMethod mm = new MyGenericMethod();
// 演示看方法提示
mm.show("aaa");
mm.show(123);
mm.show(12.45);
}
}
含有泛型的接口
定义格式：
修饰符 interface接口名<代表泛型的变量> { }
例如，
public interface MyGenericInterface<E>{//E=String;
public abstract void add(E e);
public abstract E getE();
}
使用格式：
1、定义类时确定泛型的类型
例如
public class MyImp1 implements MyGenericInterface<String> {
@Override
public void add(String e) {
// 省略...
}
@Override
public String getE() {
return null;
}
}
此时，泛型E的值就是String类型。
2、始终不确定泛型的类型，直到创建对象时，才确定泛型的类型
例如
public class MyImp2<E> implements MyGenericInterface<E> {
@Override
public void add(E e) {
// 省略...
}
@Override
public E getE() {
return null;
}
}
确定泛型：
/*
* 使用
*/
public class GenericInterface {
public static void main(String[] args) {
MyImp2<String> my = new MyImp2<String>();
my.add("aa");
}
}
泛型通配符,通配?通配未知。
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示
但是注意:一旦使用泛型的通配符?后，只能使用Object类中的共性方法，集合中元素自身方法无法使用!!!
通配符基本使用,即(能够阐述泛型通配符的作用)
泛型的通配符<?>:不知道使用什么类型来接收泛型的时候,此时可以使用?来表示未知通配符。
此时只能接收数据,不能往集合中存储数据。(因为?不确定具体是什么类型,啥类型都可以,所以不知道存什么数据)
举个例子大家理解使用即可：
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(Collection<?> coll){}//coll= new ArrayList<Integer>();
//？代表可以接收任意类型<?>接收任意的泛型
注意事项:泛型不存在继承关系 ,如Collection list = new ArrayList();这种是错误的。
Collection<Object> list = new ArrayList<String>();//报错,具体类型要求泛型前后是一致的,没有继承关系**** Collection<?> list2 = new ArrayList<Object>();//没问题,这就是?通配符可以接收任意的泛型的好处 Collection<?> list3 = new ArrayList<?>();//报错,?未知类型,没有具体的,啥都可以,创建对象要求是具体类型
泛型上下限-通配符高级使用----受限泛型
<? extends 类A>表示可以输入这个类A以及这个类A的子类,叫泛型上限,
<? super类A>表示可以输入这个类A以及这个类A的父类,叫泛型下限,用来限制泛型的范围,而不像用<?>号,啥都可以接收
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
泛型的上限：
- 格式：
类型名称 <? extends 类 > 对象名称 - 意义：
只能接收该类型及其子类
泛型的下限：
- 格式：
类型名称 <? super 类 > 对象名称 - 意义：
只能接收该类型及其父类型
比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类,因为整数也是数字
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();//儿子,是Number的儿子
Collection<String> list2 = new ArrayList<String>();//兄弟
Collection<Number> list3 = new ArrayList<Number>();//兄弟
Collection<Object> list4 = new ArrayList<Object>();//爹
getElement(list1);
getElement(list2);//报错
getElement(list3);
getElement(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
记忆下面两个,能够理解泛型上下限
//? extends Number,代表的是Number类及其子类,上限extends
//? super Number,代表的是Number类及其父类,下限
public static void getElement(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
3.占位符T的使用
public static void main(String[] args) {
Map<String, String> map = getMap("123");
Map<String, Date> dateMap = getMap(new Date());
System.out.println(JsonUtils.toJson(map));
System.out.println(JsonUtils.toJson(dateMap));
}
/**
* 泛型T的使用
*
* @param t 表示集合List传入的数据是T类型
* @param <T> 表示<T>是一个泛型
* @return Map<String, T> 表示方法返回的是T类型Map
*/
public static <T> Map<String, T> getMap(T t) {
Map<String, T> map = new HashMap<>();
map.put("key", t);
return map;
}
/**
* 泛型T的使用
*
* @param tList 表示集合List传入的数据是T类型
* @param <T> 表示<T>是一个泛型
* @return T 表示方法返回的是T类型的数据
*/
public <T> T getMap(List<T> tList) {
for (T t : tList) {
if ("11".equals(t))
return t;
}
return null;
}
//创建对象的导出
public <T> void simpleWrite(@RequestBody SimpleWriteData data, Class<T> clazz, HttpServletResponse response) throws IOException {
// 这里注意 有同学反应使用swagger 会导致各种问题，请直接用浏览器或者用postman
// response.setContentType("application/vnd.ms-excel");
response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
response.setCharacterEncoding("utf-8");
// 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
String fileName = URLEncoder.encode(data.getFileName(), "UTF-8");
response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
EasyExcel.write(response.getOutputStream(), clazz).sheet(data.getFileName()).doWrite(data.getDataList());
}
4.注意事项
①泛型数组不能初始化，因为数组在 new 不能确定A 的类型，就无法在内存开空间
错误写法: A[] a=new A[];
②静态方法不能使用类定义的泛型
图片
原因是静态成员是和类相关的,在类加载时,对象还没有创建所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化。
六.小结
泛型的使用作用小结一下：
①主要是为了规范输入输出，不符合泛型规则的在编译期报错，有效规避,将运行时期的ClassCastException，转移到了编译时期变成了编译失败。。
②避免了类型强转的麻烦。
②使用泛型，除了约定输入，还可以多种形态输出。根据输入定义的泛型类型决定输出类型。可以做到更好的复用。
1039
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
