Java基础学习之泛型（泛型方法、泛型类、通配符的使用）

柔光的暖阳◎ 2022-06-14 04:12 226阅读 0赞

Java的泛型是在JDK5.0之后引入的新特性，泛型只是在程序编译期对代码的安全防范机制，这种机制是为了方便程序员在编写代码时快速有效的检查代码中的非法类型。

**1、集合的泛型**

在Java学习初期，我们最早接触到泛型是在学习集合的这个章节中，往集合中添加元素，为了保证在遍历集合时不会出现类型转换的异常（ClassCastException）我们需要在声明集合对象时，使用泛型来规范我们添加的对象类型。例如：

List<String> list = new ArrayList<String>();

这种声明具有泛型类型的集合，只是在程序的编译期对代码进行检测。我们可以做一个实验来证明集合的泛型只是在编译器有效。

// 声明String类型的集合
    List<String> list = new ArrayList<String>();
    list.add("hello");
    
    // 获得list对象的Class字节码
    Class c = list.getClass();
    
    // 通过方法的反射，向list集合中添加Integer类型的元素
    Method m = c.getMethod("add", Object.class);
    m.invoke(list, 1);//向集合中添加整数型的1
    
    // 查看集合中元素个数
    System.out.println("集合的长度："+list.size());
    System.out.println("元素有："+list);

程序执行的结果：

集合的长度：2
    元素有：[hello, 1]

通过使用Java的反射机制，绕开编译器，在程序运行时向集合中添加泛型规定之外的类型元素，是可以成功添加的，这就足以证明，泛型只是在编译期来检查代码的中的非法类型。

**2、方法的泛型**

下面以一个具体的例子来说明方法的泛型，假设我们现在有一个需求，需要对数组中的某两个位置的元素做换位操作，

String[] arry = {
       "a","b","c","d","e"};

把下标为1的“b”和下标为3的“d”互换位置，根据这个需求，我们可以写一个方法来实现这个功能：

/** * 互换位置的方法 * @param arry 要操作的字符串类型的数组 * @param a 换位的第一个元素 * @param b 换位的第二个元素 */
    public void swop(String[] arry,int a,int b){
        // 声明第三个变量temp来实现换位
        String temp = arry[a];
        arry[a] = arry[b];
        arry[b] = temp;
    }

我们可以调用该方法来实现两个元素的位置互换

String[] arry = {
       "a","b","c","d","e"};
    
    System.out.println("换位前：");
    System.out.println(Arrays.toString(arry));
    swop(arry,1,3);
    System.out.println("换位后：");
    System.out.println(Arrays.toString(arry));

输出结果：

换位前：
    [a, b, c, d, e]
    换位后：
    [a, d, c, b, e]

通过swop()方法可以实现数组的元素换位，但是现在我们再思考一下，假如要操作的数组的类型发生了改变，之前是String类型，现在要改成Integer类型，将来可能又要改成了Double类型，那么我们编写的swop(String\[\] arry,int a,int b)方法就没法使用了。因为在方法声明的参数中，已经把数组的类型确定为String类型。  
我们要想使用一个方法来接收不同类型的参数，可以使用泛型参数来声明swop()方法，泛型的本质就是参数化类型，根据传递给泛型方法的参数类型，编译器适当的处理每一个方法的调用。  
泛型方法的声明语法是，在方法返回值类型的前面使用< E >来指定方法中的参数类型：

// 泛型方法的语法
    [public] <E> void method(E prop){}

把swop()数组元素换位的方法，改为泛型方法：

public <E> void swop(E[] arry,int a,int b){
        E temp = arry[a];
        arry[a] = arry[b];
        arry[b] = temp;
    }

在调用方法时，无论是什么数据类型的数组，都可以作为参数传递，需要注意的是，数组的类型必须是引用数据类型，不能是原始的基本数据类型，例如：

String[] arry1 = {
       "a","b","c","d","e"};
    swop(arry1,1,3);
    
    // 不可以声明为 int[] arry = {};
    Integer[] arry2 = {
       1,2,3,4,5};
    swop(arry2,0,2);

**3、类和接口的泛型**

在实例化集合对象时，我们为什么可以指定一种泛型呢？集合的接口又是如何声明泛型的呢？如果我们把这些问题搞明白了，那么我们自己也可以模仿Java官方的源码来自定义泛型类或泛型接口。  
可以在JDK API中查看Java中关于接口的声明源码，以List为例：  
![这里写图片描述][SouthEast]

在List接口的实现类中，泛型的声明：

![这里写图片描述][SouthEast 1]

可以看到，不管是接口还是实现类，都是可以声明泛型的，声明的方法很简单，就是在类名或接口名的后面直接声明泛型的标识< E >，这里的字母”E”只是泛型的一种标识，我们也可以用其他的英文字母代替。  
下面就模仿JDK API中的泛型类的声明，来自定义泛型类：

public class Demo<E> {
    
        //私有的成员变量a
        private E a;
    
        //公开的的getter和setter方法
        public void setA(E a){
            this.a = a;
        }
        public E getA(){
            return a;
        }
    }

在测试类中，可以实例化不同类型变量的对象：

Demo<Integer> d1 = new Demo<Integer>();
    d1.setA(1);
    System.out.println("d1的变量值："+d1.getA());
    
    Demo<String> d2 = new Demo<String>();
    d2.setA("hello");
    System.out.println("d2的变量值："+d2.getA());

输出结果：

d1的变量值：1
    d2的变量值：hello

需要注意的是，在类上声明的泛型，只适用于成员变量和成员方法，不能直接作用在静态方法上面，因为成员变量和成员方法是属于对象的，而静态方法是属于类的，所以在类中的静态方法上要想适用泛型，就必须按照泛型方法的声明方式来操作：

// 静态方法
    public static <T> void method(T a){}

**4、类型通配符**

当集合作为参数在方法中进行值传递时，集合上的泛型就不能以具体的类型来声明，例如：

public void method(List<Object> list){}

参数中list的泛型为Object，那就只能传递Object类型的集合，其他类型的集合都不能作为参数传递，可以使用类型通配符来声明参数中集合的泛型，类型通配符一般是使用?代替具体的类型参数。

// 通配符声明语法
    public void method(List<?> list){}

使用通配符后，就可以传递任意类型的集合。

**5、泛型的类型上限**

这里的上限概念是笔者自己定义的，大家可以自行理解。假如我们在声明泛型时，要规定具体类型的范围。比如传递的参数必须是数字，包含整数型和浮点型，那么我们就可以使用extends关键字来规定类型的具体范围：