目录：
一.什么是泛型
二.引出泛型
三.泛型语法及，泛型类的使用和裸类型(Raw Type)
的了解
.
四.泛型的编译：
五.泛型的上界
六.泛型方法
注意：在看泛型之前可以，回顾一下，包装类，包装类就是服务泛型的 ：初识JAVA中的包装类，时间复杂度及空间复杂度-CSDN博客
一.什么是泛型:
1.一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。
2.泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多类型。从代码上讲，就是对类型实现了参数化。
二.引出泛型：
1.实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？看下面代码：问题是：1.如果数据太多，每次返回，向下转型太麻烦
2.元素放置也很混乱
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);
}
}
3. 所以，泛型的主要目的：
就是指定当前的容器，要持有什么类型的对象
。
让编译
器去做检查
。
此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型
这个时候如果我们使用泛型，就可以解决这两个缺陷。泛型对数据结构学习也很重要
三.泛型语法及，泛型类的使用和裸类型(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> 代表占位符，表示当前类是一个泛型类，泛型只能接受类，所有的基本数据类型必须使用包装类！
规范：类型形参一般使用一个大写字母表示，常用的名称有：
E 表示 Element
K 表示 Key
V 表示 Value
N 表示 Number
T 表示 Type
S, U, V 等等 - 第二、第三、第四个类型
3.裸类型(Raw Type) 的了解：用上面的例子里的，主方法说明：
注意：我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制
总结：
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);
}
}
