目录
前言
如果给定一种数据类型的话，我们就没办法再使用其他数据类型了，这样的普通方法和类局限性太大了，那么有没有什么方法或者类能让我们使用更多的数据类型呢？今天我们就一起来学习一下泛型，看看泛型是如何解决这个问题的。
一、什么是泛型
首先说明下泛型是什么，泛型从字面就可看来这个适用于许多许多类型，一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。那么此时泛型就引出来了泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。
泛型的基本语法
class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class MyArray<T> {//T是一个占位符表示这是一个泛型类
//也可以用E(Element)K(Key)V(Value)N(Number)T(Type)S、U、V(第二第三第四个类型)
...
}
那应该如何创建一个泛型数组呢？
class MyArray<T> {//泛型 可以指定 顺序表类型 T是一个占位符
//public Object[] objects = new Object[10];
public T[] objects = (T[]) new Object[10];//这样其实也是不准确的 也不能直接写为 Object类型的也有可能放入任何类型的数组
//public T[] objects = new T[10];//如果这样的话，不论是String Integer,Double 都可以放入里面，那么该用什么来接受呢因此也不能直接new一个T类型的数组
//直接写成T的也会出错 底层JVM里面不允许
// 就和前面的一样报错直接写成Object 后面接收的时候会出错（数组之间的转换不能整体强转 里面的内容是没有转的）
// 最正确的应该使用反射来写
/*public MyArray(Class<T> clazz, int capacity) { //Class<T> clazz指定了类型 这样才能创建泛型数组
array = (T[])Array.newInstance(clazz, capacity);
}*/
public void set(int pos,T val){
objects[pos] = val;
}
public T get(int pos){
return objects[pos];
}
public T[] getArray(int pos){
return objects;
}
}
二、泛型类的使用
语法：泛型类 < 类型实参 > 变量名 ; // 定义一个泛型类引用new 泛型类 < 类型实参 > ( 构造方法实参 ); // 实例化一个泛型类对象
public class Fan {
public static void main(String[] args) {
//MyArray myArray = new MyArray(); 此时局限性太大 只能放int类型的
//myArray.add(1);
//使用泛型后可以自己指定类型 可以把类型作为参数 来传递
MyArray<String> myArray = new MyArray<>();
myArray.set(0,"jadsj");//编译时会自己检查对类型是否匹配 如果不匹配 会报错
myArray.set(1,"hhh");
String str = myArray.get(1);//获取一位置的元素
System.out.println(str);
MyArray<Integer> myArray1 = new MyArray<>();
myArray1.set(0,1);
int a = myArray1.get(0);
System.out.println(a);
MyArray myArray2 = new MyArray();//裸类型如果这样写的话具体的泛型是没有使用到的，又返回去什么都可以放的地步了
}
}这里的裸类型就和没有使用泛型差不多，又回到了最初的问题，裸类型是为了兼容老版本的 API 保留的机制，因此我们一般不使用了解一下就好。
三、泛型的擦除机制
通过命令：javap -c 查看字节码文件，发现所有的T都是Object。
由此推断出泛型 是编译期的一种机制 擦除机制 运行时会被擦除 泛型尖括号当中的内容不参与类型的组成 运行时<T>会被替换为Object
有关泛型擦除机制的文章截介绍： https://zhuanlan.zhihu.com/p/51452375
四、泛型的上界
在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。 但泛型只有上界，没有下界。
语法：
class 泛型类名称 < 类型形参 extends 类型边界 > {...}
//具体实现
class Myarray<E extends Number>{//E可以是Number或者Number的子类 这就是泛型的上界泛型没有下界 没有指定边界的话上界默认就是Object
public E[] objects = (E[]) new Object[10];
public void set(int pos,E val){
objects[pos] = val;
}
public E get(int pos){
return objects[pos];
}
}
public class Boundary {
public static void main(String[] args) {
Myarray<Integer> l1 = new Myarray<>();
Myarray<Double> l2 = new Myarray<>();
Myarray<Number> l3 = new Myarray<>();
//Myarray<String> l3 = new Myarray<>();这样就会报错 String不是Number的子类
l1.set(0,1);
l2.set(0,1.2);
l3.set(0,2);//此时Number类型下的都可以放
}
}五、特殊的泛型方法
语法：
方法限定符 < 类型形参列表 > 返回值类型 方法名称(形参列表){...}
一般的泛型类：
//写一个泛型类，来求出泛型数组的最大值
class Alg<T extends Comparable<T>>{//此时的T一定要实现Comparable接口，Object并没有实现这个接口 这个也算是特殊的上界
// 这里可以不认为是继承相当于拓展，T实现了这个接口
public T findMax(T[] array){
T max = array[0];
for (int i = 0; i < array.length; i++) {
//此时就不能使用正常的大于号小于号来比较大小了而应该使用compareTo方法来比较因为这里的类型可以是任何类型
if(max.compareTo(array[i]) < 0){
max = array[i];
}
}
return max;
}
}
public class Parallel {
public static void main(String[] args) {
Alg<Integer> alg = new Alg<>();//String 也可以比较
Integer[] array = {1,5,7,4,8,3};
System.out.println(alg.findMax(array));
}泛型方法：
class Alg{
public static <T extends Comparable<T>> T findMax(T[] array){//泛型方法 此时是一个静态方法，就不需要在new对象了可以直接使用
T max = array[0];
for (int i = 0; i < array.length; i++) {
if(max.compareTo(array[i]) < 0){
max = array[i];
}
}
return max;
}
}
public class Parallel {
public static void main(String[] args) {
Integer[] array = {1,5,7,4,8,3};
System.out.println(Alg.findMax(array));//不需要在实例化对象了
//System.out.println(Alg.<Integer>findMax(array));此时可以指定类型也可以不用指定，通过你给的数组就可以推出来
}
}六、通配符
通配符 通配符是用来解决泛型无法协变的问题的，协变指的就是如果 Student 是 Person 的子类，List<Studeng> 应该是List<Person>的子类，但是<...>内的东西都被擦除掉了就不构成父子类关系了，而通配符就可以解决这个问题，泛型T相当于是一个变量等待传入具体类型，而通配符相当于一种规定规定能传入哪些类型。下面可以通过代码看一下：
class Test{
public static <T> void print(ArrayList<T> list){
for (T t:list) {//这里相当于我知道了类型就是T类型
System.out.println(t);
}
}
public static void print1(ArrayList<?> list){
for (Object t:list) {//此时就不知道是什么类型了 此时相当于是可以传入任何类型
System.out.println(t);
}
}
}七、通配符的上界和下界
上界：
语法
<? extends 上界 ><? extends Number > //可以传入的实参类型是Number或者Number的子类
public class Wild {
public static void main(String[] args) {
//上界
ArrayList<Integer> arrayList1 = new ArrayList<>();
ArrayList<Double> arrayList2 = new ArrayList<>();
List<? extends Number> list = arrayList1;
//list.add(1,1);//报错，此时list的引用的子类对象有很多（Number和Number的子类），再添加的时候，任何子类型都可以，为了安全，java不让这样进行添加操作。
Number a = list.get(0);//可以通过
//Integer i = list.get(0);//编译错误，只能确定是Number子类 父类接受就可以了
}
上界当中的父子关系
ArrayList<? extends Number>（通配符的上界） 就是 ArrayList<Integer>和ArrayList<Double>的父类了 ArrayList<?>是ArrayList<? extends Number>的父类前面相当于继承了Object 这样解决了协变类型
上界存在的问题：
如果对list中添加数据的时候，报错！愿意很简单，list中存储的可能是Number也可能是Number的子类。此时添加任何类型的数据都不可以，无法确定到底是哪种类型。 通配符的上界不适合写入数据，适合读取数据，读取数据时，获取的不知道是什么具体类型
下界：
语法：
<? super 下界 ><? super Integer > //可以传入的实参的类型是Integer或者Integer的父类类型
class Person{}
class Student extends Person{}
public class Wild {
public static void main(String[] args) {
//下界
ArrayList<? super Person> list2 = new ArrayList<>();
list2.add(new Person());//只能添加Person和person的子类
list2.add(new Student());//此时list2引用的类型肯定是Peroson或Person的父类
// 因此只要比Person的粒度小都可以放入就是其子类，但是大于Person的话就不能放入了
//但是下界适合写数据 不能读取元素 只能拿Object来接受
Object objects = list2.get(0);
//Person person = list2.get(0);此时就出错了 此时Person是下界 你读取的时候如果给Person开了口子
// 那么你就可以向里面添加非Person的对象这显然是不安全的 此时编译器只知道 你获得的元素是基类类型或超类类型但并不知他具体是什么类型
// 不同于上界的向下转型而进行向上转型你又无法确定是否真的你获得的类型的超类类型除非你一直向上转型转型到Object
}
}下界中的父子关系
MyArrayList<? super Integer> 是 MyArrayList<Integer>的父类类型MyArrayList<?> 是 MyArrayList<? super Integer>的父类类型
下界中存在的问题：
下界不同于上界，下界适合写入，但不适合读取，因为添加元素的时候，我们知道list引用的对象肯定是Person或者Person的父类的集合，我们能够确定此时存储的元素的最小粒度比Person小的都可以。但是，你读取的时候，你知道是读取到的是哪个子类吗？你读取的时候如果给Person开了口子，那么你就可以向里面添加非Person的对象这显然是不安全的 此时编译器只知道 你获得的元素是基类类型或超类类型但并不知他具体是什么类型，不同于上界的向下转型而进行向上转型你又无法确定是否真的你获得的类型的超类类型除非你一直向上转型转型到Object
总结
泛型这块整体比较难，语法也比较繁琐，看起来很是抽象，因此我对于泛型的理解就是能看的栋别人写的代码就可以了，对这些语法做简单的了解就可以了，不需要过于深究。