Java进阶篇之泛型

🔥 本文由程序喵正在路上原创，CSDN首发！
💖 系列专栏：Java入门
🌠 首发时间：2022年9月13日
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🌟 一以贯之的努力不得懈怠的人生

阅读指南

泛型简介
泛型类
泛型方法
泛型接口
类型通配符
可变参数
可变参数的使用

泛型简介

泛型是 JDK5 中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

一提到参数，最熟悉的就是定义方法时如果有形参，调用此方法时就要传递实参，那么参数化类型该怎么来理解呢？

顾名思义，参数化类型就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法和泛型接口

泛型的定义格式：

<类型>：指定一种类型的格式，这里的类型可以看成是形参
<类型1，类型2…>：指定多种类型的格式，多种类型之间用逗号隔开，这里的类型可以看成是形参
将来具体调用的时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

以前的写法

import java.util.*;

public class GenericDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");

        //遍历集合
        Iterator it = c.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

学了泛型以后的写法

import java.util.*;

public class GenericDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");

        //遍历集合
        Iterator<String> it = c.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

泛型的好处：

把运行时期的问题提前到了编译期间
避免了强制类型转换

泛型类

泛型类的定义格式：

格式：修饰符 class 类名<类型> { }
例子：public class Generic { }
此处 T 可以随便写为任意标识，常见的如 T、E、K、V 等形式的参数用于表示泛型

我们来定义一个泛型类，如下

public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}
1
2
3
4
5
6
7
8
9
10
11

接着测试一波

public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new Generic<>();
        g1.setT("小明");
        System.out.println(g1.getT());

        Generic<Integer> g2 = new Generic<>();
        g2.setT(30);
        System.out.println(g2.getT());

        Generic<Boolean> g3 = new Generic<>();
        g3.setT(true);
        System.out.println(g3.getT());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果如下：
在这里插入图片描述

泛型方法

泛型方法的定义格式：

格式：修饰符<类型> 返回值类型方法名(类型变量名) { }
例子：public void show(T t) { }

定义一个泛型方法，如下

public class Generic {
    public <T> void show(T t) {
        System.out.println(t);
    }
}
1
2
3
4
5

测试一下

public class GenericDemo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("小明");
        g.show(30);
        g.show(true);
        g.show(12.34);
    }
}
1
2
3
4
5
6
7
8
9

没毛病

在这里插入图片描述

泛型接口

泛型接口的定义格式：

格式：修饰符 interface 接口名<类型> { }
例子：public interface Generic { }

我们来写一个泛型接口

public interface Generic<T> {
    void show(T t);
}
1
2
3

写一个类实现这个接口

public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}
1
2
3
4
5
6

最后测试这个类

public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new GenericImpl<>();
        g1.show("小明");

        Generic<Integer> g2 = new GenericImpl<>();
        g2.show(20);
    }
}
1
2
3
4
5
6
7
8
9

测试成功

在这里插入图片描述

类型通配符

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

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

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

类型通配符上限：
List：表示的类型是 Number 或者其子类型

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

类型通配符下限：
List：表示的类型是 Number 或者其父类型

如果你不认识 Number 类，那我们这里就简单说一下，Number 是一个抽象类，也是一个超类（即父类）。Number 类属于 java.lang 包，所有的包装类（如 Double、Float、Byte、Short、Integer 以及 Long）都是抽象类 Number 的子类

import java.util.*;

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符：
        List<?> l1 = new ArrayList<Object>();
        List<?> l2 = new ArrayList<Number>();
        List<?> l3 = new ArrayList<Integer>();
        System.out.println("---------------------");

        //类型通配符上限：
//        List l4 = new ArrayList