对于泛型！其实大家了解不是很多，在各大高校的学习中，如果你不去深入的了解泛型，老师只是会一水儿过，并不会单独去带领大家了解！！那么，笔者结合自身的学习泛型的想法，结合了一些课件，索性写出了一篇关于泛型的简单博客，来带领大家了解泛型！！
一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的 代码，这种刻板的限制对代码的束缚就会很大。
----- 来源《Java编程思想》对泛型的介绍。
简而言之，泛型：就是适用于许多许多类型，从代码上讲，就是对类型实现参数化！
在Java语法中，泛型是一个较难的语法，但是，在目前这个博客中，笔者仅仅讲解一部分，目前所接触的只是一丢丢！！后续在数据结构进阶阶段将会深入了解泛型！！
引出泛型？？
实现一个类，类中包含一个数组成员，使得这个数组可以实现存放任何类型的数据，也可以根据成员方法返回数组中的某个下标的值？？
解题思路：
- 我们之前学过的数组，只能存放指定类型的元素！
int[] array = new int[10]; String[] strs = new String[10];
- 所有类的父类默认为Object类，数组是否可以创建为Object类？？
下面请看笔者根据上面两个思路所进行书写的代码：
class MyArray {
public Object[] obj = new Object[3];
public Object getPos(int pos) {
return obj[pos];
}//返回所对应的pos下标的值
public void setObj(int pos , Object val) {
obj[pos] = val;
}//将数组下标为pos的元素赋值为val
}
public class Test {
public static void main(String[] args) {
MyArray myArray = new MyArray();
myArray.setObj(0,10);//存放整型
myArray.setObj(1,"hello"); //存放字符串
myArray.setObj(2,10.56); //存放double类型
//实现了存储任意类型的数据！
}
}对于上述代码，实现了一个数组，并且该数组内部可以存放任何数据，但是，当我们想要打印该数组中的某下标的值时，列如： double d = myArray.getPos(2); 这样写会进行报错！！
当我们进行强制类型转化的时候，double d = (double) myArray.getPos(2); 不会进行报错了！！
那么疑问又来了，笔者现在定义的数组很小，我们可以看到数组里面存储的数据类型，但是，当我们定义一个很大很大的数组时，当输出某一元素的时候，又怎能知道该下标所对应的元素类型呢？？
上述代码实现后，我们可以发现：
- 任何类型的数据都可以存放
- 获取数据的时候（double d = myArray.getPos(2) ），编译报错，必须进行强制类型转化
虽然在这种情况下，当前数组任何数据都可以存储，但是，更多情况下，我们还是希望他只能持有一种数据类型，而不是同时持有这么多的类型，所以，泛型，的主要目的，就是指定当前的容器，要 持有什么类型的对象，让编译器去做检查，此时，就需要把类型作为参数进行传递，需要什么类型，就传入什么类型！！
下面请看笔者的简单的代码：
class MyArray<T> {
//public Object[] obj = new Object[3];
public T[] obj = (T[])new Object[3];
//先这样理解，会有警告
//在Java官方不会这样去写
public T getPos(int pos) {
return obj[pos];
}//返回所对应的pos下标的值
public void setObj(int pos , T val) {
obj[pos] = val;
}//将数组下标为pos的元素赋值为val
}
public class Test {
public static void main(String[] args) {
MyArray<Integer> myArray = new MyArray<Integer>();
//实列化对象的同时，指定当前泛型类的指定参数类型是Integer
//然后就可以进行存储指定的数据类型
myArray.setObj(0,10);
myArray.setObj(1,78);
myArray.setObj(2,99);
//myArray.setObj(0,"sjd");//传入不是整型的数据，会进行报错
Integer d = myArray.getPos(2); //不需要强制类型转化
}
}对于上述代码，便是泛型的简单应用，如果您能看懂上述的代码，那么，恭喜你，对于泛型的简单应用，你已经学会了！！
对于泛型，有着下面几个简单的意义：
- 存储数据的时候，可以帮助我们进行自动的类型检查
- 获取元素的时候，可以帮助我们进行类型转化
上述的两点意义，是在编译的时候，就进行的，因此，泛型是编译时期的一种机制，在运行的时候，没有泛型的概念！！
下面来带领大家走进泛型的语法！！
语法1：
语法1：
class 泛型类名称 <类型形参列表> {
// 这里可以使用类型参数
}
语法1 的使用情况为
class ClassName<T1,T2,T3…………Tn> {
…………
}
语法2：
语法2：
class 泛型类名称 <类型形参列表> extends 继承类/* 这里可以使用类型参数 */
{
// 这里可以使用类型参数
}
class ClassName<T1,T2,T3…………Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}
对于上述的类名后的<T> 代表占位符，表示当前类是一个泛型类！！
了解一下： ；类型形参一般使用一个大写字母表示，常用的占位符有：
- E 表示：Element
- K 表示：Key
- V 表示：Value
- N 表示：Number
- T 表示：Type
- S,U,V等等，第二，第三，第四个类型
在上述占位符中，E , K , V , T 所应用的比较多！！谨记，其实对于上述的用法，笔者也……尴尬了！
值得注意的是：不可以new 一个泛型类型的数组（语法规定）比如：public T[] obj = new T[3]; 这个就是一个错误的做法！因此，泛型当中，不能实列化一个泛型类型的数组！！！
小结一下，瞬间开心：
- 泛型是将数据类型参数化进行传递
MyArray<Integer> myArray = new MyArray<Integer>();
- 使用<T>，表示当前类是一个泛型类
- 泛型目前为止的优点：数据类型参数化，编译时自动进行检查和转化
- 运行的时候，没有泛型的概念，编译完成之后，泛型被擦除为Object（擦除机制仅作了解即可）
在Java的泛型机制是在编译级别实现的，编译器生成的字节码在运行的期间，并不包含泛型的类型信息
下面笔者就Java当中，泛型的正确写法，来简单书写一下：（以后将会经常使用）Java官方的写法！
public Object[] obj = new Object[3];
public E getPos(int pos) {
return (E)obj[pos]；
}对于上述代码的简单解析：
上面笔者简单的介绍了一下泛型，那么，就用泛型来实现一个小小的练习题吧！！
实现一个泛型，泛型类里面写一个方法，来求得数组的最大值？？
对于这个方法，我们可以根据最原始的：求数组的最大值的代码，来进行简单改写，然后改编成为我们想要的代码！
抛开泛型，我们在以前在数组中寻找最大值的代码为：
//抛开泛型，我们在以前在数组中寻找最大值的代码为：
class Alg{
public int findMax(int[] array) {
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
}
}
return max;
}
}对于上述代码，想必，到目前为止，大家已经了然于胸了吧！！不用在进行讲解了！！
那么，笔者就根据上述的代码进行简单改写一下，然后就出现我们想要的泛型写法了！！请大家仔细对比一下哟！
class Alg<E extends Comparable<E>>{
public E findMax(E[] array) {
E max = array[0];
for (int i = 1; i < array.length; i++) {
if (max.compareTo(array[i]) < 0) {
max = array[i];
}
}
return max;
}
}
public class Test2 {
public static void main(String[] args) {
Alg<Integer> alg = new Alg<>();
Integer[] array = {1,4,7,29,20,48,21,23};
Integer val =alg.findMax(array);
System.out.println(val);
}
}上述代码，便是用泛型来实现要求！！代码的运行结果为：
简单解析一下吧！：
上述代码是一个泛型类，那么有没有泛型方法呢？？那么，请看笔者下面的代码吧！来带领大家用泛型方法来实现一下题目需求！！
//泛型方法
class Alg{
public <E extends Comparable<E>> E findMax(E[] array) {
E max = array[0];
for (int i = 1; i < array.length; i++) {
if (max.compareTo(array[i]) < 0) {
max = array[i];
}
}
return max;
}
}
public class Test2 {
public static void main(String[] args) {
Alg alg = new Alg();
Integer[] array = {1,4,7,29,20,48,21,23};
Integer val =alg.findMax(array);
System.out.println(val);
}
}上述的代码，就是用泛型方法来实现，求得数组中的最大值！
代码的运行结果也是正确的！！
对于这个方法，必须通过对象的引用才能调用！！
思考一下，如果我们不想通过对象的引用，那么我们应该怎么办？？
很简单，将其改为静态（static)修饰的的不就行了吗？？
请看笔者代码：
//泛型的静态方法
class Alg{
public static <E extends Comparable<E>> E findMax(E[] array) {
E max = array[0];
for (int i = 1; i < array.length; i++) {
if (max.compareTo(array[i]) < 0) {
max = array[i];
}
}
return max;
}
}
public class Test2 {
public static void main(String[] args) {
Integer[] array = {1,4,7,29,20,48,21,23};
Integer val =Alg.findMax(array);
System.out.println(val);
}
}上述代码，就是用静态（static）来修饰的！！
静态方法不依赖于对象，可以通过类名进行访问！！
对于此篇博客，有不懂的各位老铁，欢迎来咨询
