java 泛型（下）

本篇文章主要说明的是类型通配符、可变参数、可变参数的使用等。

在学习之前，希望能对泛型有个大概了解，可参考链接 java 泛型（上）-CSDN博客

也希望对泛型类、泛型接口、泛型方法有个大概的认识及使用，可参考链接

java 泛型（中）-CSDN博客

1、类型通配符

（1）为了表示各种泛型List的父类，可以使用类型通配符。

类型通配符：<?>
List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型。
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中。

（2）如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限。

类型通配符上限：<? extends 类型>
List<? extends Number>：它表示的类型是Number或者其子类型

（3）除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限。

类型通配符下限：<? super 类型>
List<? super Number>：它表示的类型是Number或者其父类型

（4）代码实现

看了上面的是不是有点蒙，所以，为了更好理解，先记住这张图。

然后，看代码实现

package generics;

import java.util.ArrayList;
import java.util.List;

public class GenericsDemo5 {
    public static void main(String[] args) {
        List<?> list = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("------------");

        //类型通配符上限：<? extends 类型>
        //上限是Number，可右边是Object，所以报错
        // List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        System.out.println("------------");

        //类型通配符下限：<? super 类型>
         List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
        //下限是Number，可右边是Integer，所以报错
        // List<? super Number> list9 = new ArrayList<Integer>();
        
    }
}

2、可变参数

（1）可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

（2）格式：修饰符返回值类型方法名(数据类型.. 变量名){}

（3）范例：public static int sum(int... a){}

（4）可变参数注意事项

这里的变量其实是一个数组；
如果一个方法有多个参数，包含可变参数，可变参数要放在最后。

（5）代码实现

package generics;

import java.util.ArrayList;
import java.util.List;

public class GenericsDemo6 {
    public static void main(String[] args) {
        System.out.println(sum(10, 20));
        System.out.println(sum(10, 20, 30));
        System.out.println(sum(10, 20, 30, 40));
    }

    public static int sum(int... a) {
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        return sum;
    }

    //如果有可变参数，可变参数要放在后面
    //public static int sum(int... a,int b) {
    //正确
//    public static int sum(int b, int... a) {
//        return 0;
//    }

}

运行结果

3、可变参数的使用

（1）Arrays工具类中有一个静态方法

public static <T> List<T> asList(T... a)：返回由指定数组支持的固定大小的列表
返回的集合不能做增删操作，可以做修改操作

（2）List接口中有一个静态方法

public static <E> List<E> of(E... elements)：返回包含任意数量元素的不可变列表
返回的集合不能做增删改操作

（3）Set接口中有一个静态方法

public static <E> Set<E> of(E.. elements)：返回一个包含任意数量元素的不可变集合
在给元素的时候，不能给重复的元素
返回的集合不能做增删操作，没有修改的方法

（4）代码实现

package generics;

import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class GenericsDemo7 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("hello", "world", "java");
       // list.add("he"); // UnsupportedOperationException
        //list.remove("hello"); // UnsupportedOperationException
        list.set(2, "11111");
        System.out.println(list);

        List<String> list2 = List.of("hello", "world", "java");
//         list2.add("he"); // UnsupportedOperationException
//        list2.remove("hello"); // UnsupportedOperationException
//        list2.set(2, "11111");// UnsupportedOperationException
        System.out.println(list2);
        //不能给重复元素
//        List<String> list3 = Set.of("hello", "world", "java", "java");
        Set<String> list3 = Set.of("hello", "world", "java");
//        list3.add("he"); // UnsupportedOperationException
//        list3.remove("hello"); // UnsupportedOperationException
        //没有修改方法
       // list3.set(2, "11111");
        System.out.println(list3);
    }

}

运行结果