JavaSE之可变参数和泛型

可变参数

使用场景：参数类型确定，数量不确定，可以使用可变参数进行设置

格式：…

用可变参数来编写求和的方法：

//调用方法时，可以传任意数量的实参，类型必须是int
public static int getSum(int... a){
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i];
        }
        return sum;
    }
1
2
3
4
5
6
7
8

public static void main(String[] args) {
        System.out.println(getSum(1, 2));
        System.out.println(getSum(1, 2, 3));
        System.out.println(getSum(1, 2, 3, 4));
    }
1
2
3
4
5

使用可变参数就节省了去方法重载的时间。

可变参数本质就是数组int…a 等价于 int[] a

注意事项：

1.方法中，可变参数只能有一个

2.可变参数要放在参数列表的最后

泛型

泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制

好处：

把运行时期的问题提前到了编译期间

避免了强制类型转换

统一数据类型

没有使用泛型，元素类型是任意的，弊端就是获取数据的时候，类型无法明确

public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("hello");
        //默认是Object类，那么就只能使用Object中的方法，
        //无法调用特有的方法
        Object o = list.get(0);
        //需要进行强转，才能调用length方法，可能存在类型转换异常
        String s = (String) list.get(0);
        System.out.println(s.length());
    }
1
2
3
4
5
6
7
8
9
10

泛型定义格式：
<类型>
比如：< E > < T >

<类型1，类型2>

定义泛型的地方
泛型类，ArrayList

定义一个泛型类，在new的时候确定泛型类型，如下使用的就全是String类型

class Person<E>{
    private E name;
    private E age;
}
1
2
3
4

Person<String> p1 = new Person<>();
1

泛型接口 List

泛型方法

	//是在定义泛型，在返回值之前定义，T[]是使用泛型
    //如果希望数组可以是其他类型，可以重载，弊端是方法需要定义多个
    //可以考虑使用泛型方法定义
    public static <T> void getSum(T[] arr){

    }
1
2
3
4
5
6

泛型通配符

前景导出：

定义Jeep,Bus继承自Car

//Jeep
public class Jeep extends Car{
}
1
2
3

//Bus
public class Bus extends Car{
}
1
2
3

//Car
public class Car {
}
1
2
3

public static void main(String[] args) {
        ArrayList<Car> cars = new ArrayList<>();
        ArrayList<Jeep> jeeps = new ArrayList<>();
        ArrayList<Bus> buses = new ArrayList<>();

        play(cars);
        //报错
        play(jeeps);
        play(buses);

    }
    //定义方法接收汽车类型，泛型不支持多态
    public static void play(ArrayList<Car> list){

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

发现了泛型不支持多态，原本想法是Jeep和Bus继承了Car,那么也应该能用，实际上是不支持。

解决方法：使用通配符

通配符格式： ?

	//让集合的泛型可以通配任何类型，可以使用?通配符
    public static void play(ArrayList<?> list){

    }
1
2
3
4

	//表示可以通配Car以及Car的子类
    public static void play(ArrayList<? extends Car> list){

    }
1
2
3
4

	//表示可以通配Car以及Car的父类
    public static void play(ArrayList<? super Car> list){

    }
1
2
3
4

类型通配符的上下限

? super Car
泛型只能是Car以及Car的父类，规定了下边界

? extends Car
泛型只能是Car以及Car的子类，规定了上边界

最后

如果你对本文有疑问，你可以在文章下方对我留言，敬请指正，对于每个留言我都会认真查看。