Java泛型
目录
一、泛型是一种约束
1. 泛型
2. 泛型的优点
二、泛型的使用
1. 泛型的注意事项
2. 泛型的语法
泛型类
泛型接口
泛型方法
三、泛型通配符
1. 什么是类型通配符
2. 类型通配符的上限
3. 类型通配符的下限
4. 代码示例
四、类型擦除
1. 代码验证
2. 无限制类型擦除：把T转换成Object
3. 有限制类型擦除：把T转换成上限
4. 擦除方法
如果本篇博客对您有一定的帮助，大家记得留言+点赞+收藏哦
一、泛型是一种约束
JAVA推出泛型以前，程序员可以构建一个元素类型为Object的集合，该集合能够存储任意的数据类型对象，而在使用该集合的过程中，需要程序员明确知道存储每个元素的数据类型，否则很容易引发ClassCastException异常。
1. 泛型
Java泛型（generics）是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。
泛型的本质就是参数化类型(类型参数化)，也就是所操作的数据类型被指定为一个参数。
private static void m2() {
ArrayList list=new ArrayList<>();
list.add("333");
list.add("string");
//list.add(88); 编译期检查
for (String s : list) {
System.out.println(s); //减少了数据类型转换
}
}
/**
* 未使用泛型之前
*/
private static void m1() {
ArrayList objects = new ArrayList();
objects.add("111");
objects.add(88);
objects.add(true);
for (Object object : objects) {
System.out.println(object);
}
} 2. 泛型的优点
1.类型安全，编译期检查
2.消除了强制类型的转换、提高效率
二、泛型的使用
1. 泛型的注意事项
- 泛型类，如果没有指定具体的数据类型，此时，操作类型是Object
- 泛型的类型参数只能是类类型，不能是基本数据类型
- 泛型类型在逻辑上可以看成是多个不同的类型，但实际上都是相同类型
- 泛型的使用，类型参数化，泛型标识，由外部使用类来指定
- 可以结合后面的泛型擦除理解，泛型擦除之后 Generic < String > 和Generic< Integer >都是Generic类。
2. 泛型的语法
泛型类
T：type
E：element
K: key
V :value
？：表示不确定的java类型
一般是单个大写字母
/**
* 泛型的使用，类型参数化
* T:泛型标识，由外部使用类来指定
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/8/19 - 10:50
*/
public class Generics {
private T key;
public Generics() {
}
public Generics(T key) {
this.key = key;
}
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
public static void main(String[] args) {
//泛型类在创建对象的时候，来指定具体的数据类型
//泛型极大的提高了代码的复用性
Generics generics=new Generics<>();
generics.setKey("aba");
String key = generics.getKey();
System.out.println(key);
//泛型类在创建对象的时候，没有指定类型，默认使用Object
Generics g=new Generics();
//泛型不支持基本数据类型
Generics g1=new Generics();
System.out.println(g1.getClass()==(generics).getClass());//同一个字节码文件
}
- 子类也是泛型类，子类和父类的泛型类型要一致
class ChildGenericextends Generic - 子类不是泛型类，父类要明确泛型的数据类型
class ChildGeneric extends Generic- 泛型是从子到父，向上传递
父类
/**
* 泛型父类
*
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/8/19 - 11:17
*/
public class Parent {
private T key;
public Parent() {
}
public Parent(T key) {
this.key = key;
}
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
} 子类*2
/**
* 子类要与父类的泛型标识一样
* 子类也是泛型类，子类和父类的泛型类型要一致
* 子类可以泛型拓展
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/8/19 - 11:19
*/
public class ChildFirst extends Parent{
//ChildFirst
}
/**
* 子类不是泛型类，父类要明确泛型的数据类型
* 泛型是从子到父，向上传递
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/8/19 - 11:25
*/
public class ChildSecond extends Parent{
} 泛型接口
语法
interface 接口名称 <泛型标识，泛型标识，…> {
泛型标识 方法名();
.....
}
- 实现类也是泛型类，实现类和接口的泛型类型要一致
- 实现类不是泛型类，接口要明确数据类型
泛型方法
1.用法
泛型方法是在调用方法的时候指明泛型的具体类型。
2.语法:
修饰符 返回值类型 方法名(形参列表) {
方法体...
} 3.说明：
- public与返回值中间非常重要，可以理解为声明此方法为泛型方法。
- 只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
- < T >表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
- 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
- 泛型方法的调用，类型是调用方法的时候指定的
/**
* 普通方法：泛型类的成员方法
*/
public T getKey() {
return key;
}
/**
* 普通方法：泛型类的成员方法
*/
public void setKey(T key) {
this.key = key;
}
/**
* 定义泛型方法
* @param list 参数
* @param 泛型标识，具体类型，有调用方法的时候来指定
* @return 结果
*/
public E getRecord(ArrayList list){
Random r=new Random();
return list.get( r.nextInt(list.size()));
}
/**
* 静态泛型方法
*/
public static void getRecord(E e,K k,V v){
System.out.println("e: "+e);
System.out.println("k: "+k);
System.out.println("v: "+v);
} 泛型方法与普通方法的区别：
1.泛型方法可以用static修饰，普通方法不能使用static修饰。
2.泛型方法是调用时才指定类型，普通方法要跟从类，指定类型
3.泛型方法能够是方法独立于类而产生变化，更加灵活
三、泛型通配符
1. 什么是类型通配符
类型通配符一般是使用"?"代替具体的类型实参。
所以，类型通配符是类型实参，而不是类型形参。
如何理解这里说的实参呢，因为泛型是将类型参数化了，所以类型通配符是类型实参
2. 类型通配符的上限
语法：
类/接口
要求该泛型的类型，只能是实参类型，或实参类型的子类类型。
规定参数继承自 实参类型
上限通配符，集合 不能填充元素
3. 类型通配符的下限
语法：
类/接口
要求该泛型的类型，只能是实参类型，或实参类型的父类类型。
下限通配符，集合 可以填充元素
4. 代码示例
public class Box {
private E first;
public E getFirst() {
return first;
}
public void setFirst(E first) {
this.first = first;
}
}
/**
* 通配符：表示任意类型
* @param box
*/
public static void showBox1(Box box){
Object first = box.getFirst();
System.out.println(first);
}
/**
* 上限通配符 规定参数继承自 Number，想想多态
* @param box
*/
public static void showBox(Box box){
//上限通配符，集合 不能填充元素
Number first = box.getFirst();
System.out.println(first);
}
/**
* 下限通配符 ，规定只能是Number或者Number的父类
* @param box
*/
public static void showBox2(Box box){
//下限通配符，集合 可以填充元素
Object first = box.getFirst();
System.out.println(first);
} 四、类型擦除
泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是泛型代码能够很好地和之前版本的代码兼容。那是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为–类型擦除。
1. 代码验证
public static void main(String[] args) {
ArrayList strList = new ArrayList<>();
ArrayList intList = new ArrayList<>();
System.out.println(strList.getClass().getSimpleName());
System.out.println(intList.getClass().getSimpleName());
//发生 类型擦除了
System.out.println("-------------");
// 使用反射验证
Erasure erasure=new Erasure<>();
Field[] declaredFields = erasure.getClass().getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
//private java.lang.Object com.promsing.generics.demo7.Erasure.key
System.out.println(declaredField.getName());
//key
System.out.println(declaredField.getType().getName());
//java.lang.Object
}
} 2. 无限制类型擦除：把T转换成Object
3. 有限制类型擦除：把T转换成上限
4. 擦除方法
