一、泛型简介

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

该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口，好处是把运行时期的问题提前到了编译期间，避免了强制类型转换。

二、泛型类

格式：修饰符 class 类名<类型>{ }

注意：此处 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;
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        // 指定String类型
        Generic<String> g1 = new Generic<>();
        g1.setT("孙悟空");
        System.out.println("t = " + g1.getT());

        // 指定Integer类型
        Generic<Integer> g2 = new Generic<>();
        g2.setT(500);
        System.out.println("t = " + g2.getT());
        
        // 指定其它类型...
    }
}

运行：

t = 孙悟空
t = 500

三、泛型方法

格式：修饰符 <类型> 返回值类型方法名(类型变量名) { }

示例：

public class Generic {
    // 泛型方法，若需返回值，则将void也改为T
    public <T> void show(T t) {
        System.out.println("t = " + t);
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        Generic g = new Generic();
        // 传入String类型
        g.show("孙悟空");
        // 传入int类型
        g.show(500);
        // 传入其它类型...
    }
}

运行：

t = 孙悟空
t = 500

四、泛型接口

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

示例：

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

// 泛型接口实现类
public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println("t = " + t);
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        // 指定String类型
        GenericImpl<String> g1 = new GenericImpl<>();
        g1.show("孙悟空");

        // 指定Integer类型
        GenericImpl<Integer> g2 = new GenericImpl<>();
        g2.show(500);
        
        // 指定其它类型...
    }
}

运行：

t = 孙悟空
t = 500

五、类型通配符

类型通配符：<?>
示例：List<?> 表示 List 元素类型未知，可以匹配任何类型。

类型通配符上限：<? extends 类型>
示例：List<? extends Number> 表示 List 元素类型是 Number 或者其子类型。

类型通配符下限：<? super 类型>
示例：List<? super Number> 表示 List 元素类型是 Number 或者其父类型。

示例：

public class Test {
    public static void main(String[] args) {
        // 类型通配符：<?>
        // 表示List元素类型未知，可以匹配任何类型
        List<?> l1 = new ArrayList<Object>();

        // 类型通配符上限：<? extends 类型>
        // 表示List元素类型是Number或者其子类型
        List<? extends Number> l2 = new ArrayList<Number>();
        List<? extends Number> l3 = new ArrayList<Integer>();
        //List<? extends Number> l4 = new ArrayList<String>(); //报错

        // 类型通配符下限：<? super 类型>
        // 表示List元素类型是Number或者其父类型
        List<? super Number> l5 = new ArrayList<Number>();
        List<? super Number> l6 = new ArrayList<Object>();
        //List<? super Number> l7 = new ArrayList<Integer>(); //报错
    }
}

六、可变参数

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

说明：可变参数又称参数个数可变，用作方法的形参出现。

注意：这里的变量其实是一个数组，若一个方法有多个参数，包含可变参数，可变参数要放在最后。

示例：

public class Test {
    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));
        // System.out.println(sum(10, 20, 30, 40, ...N));
    }
	
    // 求和
    public static int sum(int... num) {
        int sum = 0;
        for (int i : num) {
            sum += i;
        }
        return sum;
    }
}

运行：

30
60
100

Java — 泛型