大家好！我是保护小周ღ，本期为大家带来的是 Java的泛型，会来大家初步了解什么是泛型，以及泛型的使用，感受一手泛型的思想，面向对象编程太爽了~

一、泛型是什么？

二、泛型的语法

三、包装类

3.1 包装类的装箱/装包操作

3.2 包装类的拆箱/拆包操作

四、泛型的运用

五、泛型的上界

六、泛型的方法

一、泛型是什么？

泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化（传基本数据类型的包装类）以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。 —————搜狐百科

泛型是在JDK1.5引入的新的语法，泛型：从字面上来讲：“泛” 我觉得是很多的意思，“型”即是，相当于通用类型。从代码上讲，就是对类型实现了参数化。什么类型都可以传参；

二、泛型的语法

class 泛型类名称 <类型参数列表> {
    
}

class genericName <T1,T2,T3,T4……>{ 
    
}

class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
  // 这里可以使用类型参数
}

class ClassName<T1, T2, ...,Tn>extends ParentClass<T1> {
    // 可以只使用部分类型参数
}

1. 类名后的<T > 代表占位符，表示当前类是一个泛型类，语言规范<大写字母>，一般使用有意义的字母，见名思意，T 代表 Type 用于描述单个类型，E代表　Element 用于描述将来会使用多个类型，其实任意单词都可，但要注意代码规范即可。

2. 不能 new 泛型类型的数组，数组和泛型之间的一个重要区别是它们如何强制执行类型检查。具体来说，数组在运行时存储和检查类型信息。然而，泛型在编译时检查类型错误。如果使用泛型数组，运行的时候，直接转给某类型的数组，编译器认为是不安全的，且定义数组需要一个确定类型，而泛型，Java 不认为是一种确认类型，是不安全的。

泛型类的使用：

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

MyArray<Integer> list = new MyArray<Integer>();

三、包装类

在Java 中，因为基本数据类型不是继承 Object 类，为了能在泛型代码中使用基本数据类型，且Java又是完全面向对象的程序设计语言，所以每一个基本数据类型都有对应的包装类，包装类包含了基本数据类型，可以将基本数据类型转换成引用类型，那么一个类，里面就有许多方法，例如：包装类.value() ;就可以把某种数据类型转换成包装类对应的基本数据类型（在符合规则的情况下），有了包装类，基本数据类型可以面向对象编程。

例：

以此类推，只要符合规则，各类型之间也可以使用包装类的方法进行转换，但是 boolean 类型是不可以转换的。

3.1 包装类的装箱/装包操作

装箱/装包：把基本数据类型转换成引用类型（对应的包类型）

在进行自动“装箱”的时候，IDEA会自动调用一个 Integer.valueOf() 方法，来帮我们转换，

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
}

3.2 包装类的拆箱/拆包操作

拆箱：把引用类型转化成基本数据类型

public int intValue() {
   return value;
}

四、泛型的运用

从代码上讲，泛型就是对类型实现了参数化。什么类型都可以传参；那为啥不直接使用 Objcet 来接收数据呢？包装类也是继承了 Objcet 类的，我说：可以，但是不好用！

例题：

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。

用Objcet 类型来做这个题看效果：

class UniversalArray {
    private Object[] obj = new Object[3];//定义一个Object 类型的数组

    public Object getObj(int pos) { //返回数组pos 下标的值
        return obj[pos];
    }

    public void setObj(int pos, Object val) { //给pos下标的数组元素赋值为val
        this.obj[pos] = val;
    }
}
public class Test3 {
    public static void main(String[] args) {
        UniversalArray array = new UniversalArray();
        array.setObj(0,10);  //调用set构造方法赋值
        array.setObj(1,"abc");
        array.setObj(2,3.14);

        // 我们返回 Object 类型的数据需要手动强转才可以使用，
        int val1 =  (int) array.getObj(0);
        String val2 =  (String) array.getObj(1);
        double val3 = (double) array.getObj(2);

        System.out.println(val1);
        System.out.println(val2);
        System.out.println(val3);
    }
}

通过以上代码，我们确实使用Object 数组做到了什么数据都可以存储，但是在获取数据的时候，必须要强制类型转换才可以使用，而且你还要知道强转的类型才可以，在数据量特别大且复杂的时候，就把自己给绕晕了，不建议使用。

用泛型这种编程思量来做这个题看效果：

首先我们想要的效果是，一个通用性数组，可以存储任意你指定类型的数据，但是最好一次只存一种类型的数据（使用时避免头晕），且不需要对拿到的数据进行强转即可使用。

class UniversalArray<E> { //泛型类

    private Object[] obj = new Object[3];//定义一个Object 类型的数组

    public E getObj(int pos) { //返回数组pos 下标的值
        return (E) obj[pos]; //强换为指定类型的数据类型
    }

    public void setObj(int pos, E val) { //给pos下标的数组元素赋值为val
        this.obj[pos] = val;
    }
}
public class Test3 {
    public static void main(String[] args) {
        //实例化一个泛型类对象 array1
        UniversalArray<Integer> array1 = new UniversalArray<Integer>();
        // < > 中指定的的参数必须是引用类型,这里我们指定他为 Integer 类型
        array1.setObj(0,10);  //调用set构造方法对Object 数组赋值
        array1.setObj(1,20);
        array1.setObj(2,30);

        //Object 类型被强转为 E 类类型，而 E 类型又被我们 指定为 Integer
        int val1 = array1.getObj(0); //所以这里发生的是 隐形的拆箱操作，将Integer 引用类型转换成基本类型
        int val2 = array1.getObj(1);
        int val3 = array1.getObj(2);

        System.out.println(val1);
        System.out.println(val2);
        System.out.println(val3);

        //实例化一个泛型类对象 array2
        UniversalArray<String> array2 = new UniversalArray<String>();
        // < > 中指定的的参数必须是引用类型,这里我们指定他为 String 类型
        array2.setObj(0,"1233");  //调用set构造方法对Object 数组赋值
        array2.setObj(1,"abc");
        array2.setObj(2,"helloWorld");

        //Object 类型被强转为 E 类类型，而 E 类型又被我们 指定为 String 类型
        String str1 = array2.getObj(0);
        String str2 = array2.getObj(1);
        String str3 = array2.getObj(2);

        System.out.println(str1 + " " + str2 + " " + str3);
    }
}

1. 我们定义了一个泛型类，泛型类中有一个Object 类型的数组，我们提供了get 和 set 方法可以对该数组进行操作。

2. 在测试类Test3 实例化了两个泛型类的对象，array1 和 array2 但是我们对其 < >中指定的数据类型不一样，array1 指定为 Integer ，所以我们可以就可以将 array1 该对象的 Object 数组当成 Integer 类型的数组进行操作，array2 指定为 String 类型，所以我们就拥有了一个 String 类型数组。

3. 我们还可以定义 array3 、array4、 array5 ……许多对象，将他们指定为不同的数据类型，拥有通用类型的数组，实际上我们只定义了一个泛型类，这样是不是大大减少了代码的冗余。

4. 泛型的主要目的就是：指定当前的当前容器，要持有某个类型的对象，就像是传参，你希望他是什么类型，就传入什么类型参数。

泛型：在存储数据的时候，相当于预定了将来的数据类型，实际上还是Object 类型，在获取元素的时候，自动的帮我们进行类型转换。泛型实际上是编译时期的一种设计思想（把类型作为参数传递），在运行的时候，就没有这个概念了。

泛型只能接受类，所有的基本数据类型必须使用包装类。

五、泛型的上界

泛型的上界是什么意思呢，在定义泛型类时，有时需要对传入的类型变量做一定的约束，或者是继承一些功能，可以通过类型边界来约束。

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

举个例子：

以上代码更能体现泛型是在编译时期对类型进行检查的机制。

也可以通过继承一些功能

class  Alg <E extends Comparable<E>>{ //泛型的上界
    public E findMax(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;
    }
}

“E” 类型是可以把他（理解）是通用类型，他跟 Object 是不一样的，Object 是具体的，而泛型与之相比是抽象的概念，所以以 “E” 定义的变量没有具体的类型，也没有继承对应包装类的各种方法，所以在这种情况下，要想使用具体类型的方法，我们就使得“E” 这个“类型”继承一个Comparable 接口或者是其他接口，这样 “E”类型的变量，方法等就可以实现 Comparable 接口里的方法。

六、泛型的方法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) {

 }

有泛型的类，那自然有泛型的方法，接下来博主给大家演示一手泛型方法有多厉害。

public class Test4 {
   //交换数据
    private static <E> void swop(E[] arr, int i, int j) {
        E tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    public static <E extends  Comparable<E>> void sort (E[] array) {
        //冒泡
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if( array[j].compareTo(array[j+1]) > 0) {
                    swop(array, j, j+1);
                }
            }
        }
    }
    public static void main(String[] args) {
        //整型数组
        Integer[] arr = {10,2,1,3,4,5};
        Test4.<Integer>sort(arr);
        System.out.println(Arrays.toString(arr));

        Double[] doubArr = {3.14, 2.2, 5.1, 1.11,3.1};
        Test4.sort(doubArr);
        System.out.println(Arrays.toString(doubArr));

        Character[] charArr = {'b','d','c','a','e'};
        Test4.sort(charArr);
        System.out.println(Arrays.toString(charArr));
    }
}