目录：

注意：在看泛型之前可以，回顾一下，包装类，包装类就是服务泛型的 ：初识JAVA中的包装类，时间复杂度及空间复杂度-CSDN博客

一.什么是泛型:  

二.引出泛型：

class My_array {public Object[] array = new Object[10];public Object getArray(int pos) {return array[pos];}public void setArray(int pos, Object val) {this.array[pos] = val;}
}public class Test {public static void main0(String[] args) {My_array my_array = new My_array();//放置元素太乱，my_array.setArray(0, "haha");my_array.setArray(1, 2);//如果数据太多，每次返回，向下转型太麻烦String str = (String) my_array.getArray(0);}
}

三.泛型语法及，泛型类的使用和裸类型(Raw Type) 的了解

1.语法 ：下面给出一些泛型类的语法：

class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> {
}class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}

2.泛型类的使用：对引出泛型存在缺陷的，代码进行改写：

  
public static void main(String[] args) {//指定你要的类型My_array<Integer/*只能写类类型*/> my_array = new My_array</*Integer*/>();//        my_array.setArray(0, "haha");//自动类型检查my_array.setArray(0, 2);Integer a =  my_array.getArray(0);//自动类型转换System.out.println(a);/*** 想给数组放你想要的类型*/My_array<String> my_array1 = new My_array<>();my_array1.setArray(0, "haha");String str = my_a rray1.getArray(0);System.out.println(str);}}/*** 用泛型*///这个E相当于占位符
class My_array<E> {public Object[] array = new Object[10];public E getArray(int pos) {return (E) array[pos];}public void setArray(int pos, E val) {this.array[pos] = val;}
}

 注意：类名后的 <T> 代表占位符，表示当前类是一个泛型类，泛型只能接受类，所有的基本数据类型必须使用包装类！ 

总结：

1. 泛型是将数据类型参数化，进行传递

2. 使用 <T> 表示当前类是一个泛型类。

3. 泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

   四.泛型的编译：

1. 擦除机制： 在Java虚拟机运行时，是不允许泛型 ，存在的，所以 在编译成字节码文件过程 中 会将所有的<E>替换为Object这种机制，我们称为：擦除机制。（可以到out目录，通过反汇编来查看） （命令：javap）

例子：下面这个代码中的，set方法的参数被擦除，为Object类：

class My_array<E> {public Object[] array = new Object[10];public E getArray(int pos) {return (E) array[pos];}public void setArray(int pos, E val) {this.array[pos] = val;}
}

   五.泛型的上界：

1.语法：这里用到extends关键字

class 泛型类名称<类型形参 extends 类型边界> {
...
}

2.来个例子：这里E继承了，Comparable接口，下面就可以使用，compareTo方法来，比较，

如果不规定这个边界，那么通过擦除机制，就不能直接比较。规定了边界，就有了方法来比较

class Alg<E extends Comparable<E>> {public E Find_Max(E[] array) {E max = array[0];for (int i = 0; i < array.length; i++) {if (max.compareTo(array[i]) < 0) {max = array[i];}}return max;}
}public class Test {public static void main1(String[] args) {Integer[] array = new Integer[]{1,2,3,4,5,6};Alg<Integer> alg = new Alg<>();int ret = alg.Find_Max(array);//自动类型转换System.out.println(ret);}
}

这里还有一点值得注意：这里E继承了，Comparable接口，后没有重写，compareTo方法，因为你传的泛型参数（Integer）已经实现了Comparable接口，可以直接使用。

   六.泛型方法：

 1.  定义语法：方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }

class Alg2 {public<E extends Comparable<E>>  E Find_Max(E[] array) {E max = array[0];for (int i = 0; i < array.length; i++) {if (max.compareTo(array[i]) < 0) {max = array[i];}}return max;}
}public static void main2(String[] args) {Alg2 alg2 = new Alg2();Integer[] array = new Integer[]{1,2,3,4,5,6};int ret = alg2./*<Integer>*/Find_Max(array);System.out.println(ret);}

2.静态泛型方法：可以不用每次，实例化对象去调用方法，因为静态行为，不依赖对象，可以直接用类名调用

代码如下：

class Alg3 {public static  <E extends Comparable<E>>  E Find_Max(E[] array) {E max = array[0];for (int i = 0; i < array.length; i++) {if (max.compareTo(array[i]) < 0) {max = array[i];}}return max;}
}/*** 泛型静态方法2:加static* 静态行为，不依赖对象，可以直接用类名调用（不用每次,new对象）*/public static void main(String[] args) {Integer[] array = new Integer[]{1,2,3,4,5,6};int ret = Alg3./*<Integer>*/Find_Max(array);System.out.println(ret);}
}