背景

在没有泛型前，一旦把一个对象丢进集合中，集合就会忘记对象的类型，把所有的对象都当成 Object 类型处理。当程序从集合中取出对象后，就需要进行强制类型转换，这种转换很容易引起 ClassCastException 异常。

定义

程序在创建集合时指定集合元素的类型。增加了泛型支持后的集合，可以记住集合中元素的类型，并可以在编译时检查集合中元素的类型，如果试图向集合中添加不满足类型要求的对象，编译器就会报错。

示例

集合使用泛型

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DiamondTest {
    public static void main(String[] args) {
        List<String> books = new ArrayList<>();
        books.add("learn");
        books.add("java");
        books.forEach(book -> System.out.println(book.length()));

        Map<String, List<String>> schoolsInfo = new HashMap<>();
        List<String> schools = new ArrayList<>();
        schools.add("i");
        schools.add("love");
        schoolsInfo.put("java", schools);
        schoolsInfo.forEach((key, value) -> System.out.println(key + "--->" + value));
    }
}

类、接口使用泛型

public class Apple<T> {
    private T info;
    public Apple() {}
    public Apple(T info) {
        this.info = info;
    }
    public void setInfo(T info) {
        this.info = info;
    }
    public T getinfo() {
        return this.info;
    }
    public static void main(String[] args) {
        Apple<String> a1 = new Apple<>("Apple");
        System.out.println(a1.getinfo());
        Apple<Double> a2 = new Apple<>(5.67);
        System.out.println(a2.getinfo());
    }
}

类型通配符

需求分析

public void test(List<Object> c) {
    for (int i = 0; i < c.size(); i++) {
        System.out.prinln(c.get(i));
    }
}

这个方法声明没有任何问题，但是调用该方法实际传入的参数值，可能会出错。考虑如下代码：

List<String> strList = new ArrayList<>();
test(strList); // 编译出错，表明 List<String> 对象不能被当成 List<Object> 对象使用，也就是说 List<String> 并不是 List<Object> 的子类。

问题解决

为了表示各种泛型 List 的父类，可以使用类型通配符。List<?> 表示元素类型未知的 List。这个 ？号被称为通配符，它可以匹配任何类型。将上面的代码，改为如下形式：

public void test(List<?> c) {
    for (int i = 0; i < c.size(); i++) {
        System.out.prinln(c.get(i));
    }
}

现在传入任何类型的 List，程序可以正常打印集合 c 中的元素。

不过集合中元素的类型会被当成 Object 类型对待。

类型通配符的上限

需求分析

当使用 List<?> 时，表明它可以是任何泛型 List 的父类。如果我们只希望它代表某一类泛型 List 的父类，java 提供了被限制的泛型通配符。

看如下代码：

public abstract class Shape {
    public abstract void draw(Canvas c);
}

public class Circle extends Shape {
    @Override
    public void draw(Canvas c) {
        System.out.println("在画布上" + c + "上画一个圆");
    }
}

public class Rectangle extends Shape {
    @Override
    public void draw(Canvas c) {
        System.out.println("把一个矩形画在画布" + c + "上");
    }
}

import java.util.List;

public class Canvas {
    public void drawAll(List<Shape> shapes) {
        for (Shape s : shapes) {
            s.draw(this);
        }
    }
}

下面代码将引起编译错误，因为 List<Circle> 并不是 List<Shape> 的子类型，所以不能把 List<Circle> 对象当成 List<Shape> 类用。

// 错误示范
List<Circle> circleList = new ArrayList<>();
Canvas c = new Canvas();
c.drawAll(circleList); 

问题解决

方法一：通过类型通配符解决，即 List<?> 方式。

需要进行强制类型转换，因为 List<?> 中元素默认为 Object 类型

import java.util.List;

public class Canvas {
    public void drawAll(List<?> shapes) {
        for (Object obj : shapes) {
            Shape s = (Shape)obj // 但是需要进行强制类型转换，因为前面提到过 List<?> 中元素默认为 Object 类型
            s.draw(this);
        }
    }
}

方法二：使用被限制的泛型通配符

List<? extends Shape> 可以表示 List<Circle> 和 List<Rectangle> 的父类。只要 List 尖括号里的类型是 Shape 的子类即可。

import java.util.List;

public class Canvas {
    public void drawAll(List<? extends Shape> shapes) { // 使用被限制的泛型通配符
        for (Shape s : shapes) {
            s.draw(this);
        }
    }
}

形参类型上的应用

在定义类型形参时设定类型通配符上限。以此来表示传递给该类型形参的实际类型必须是该上限类型或者其子类。

public class Apple<T extends Number> {
    T col;
    public static void main(String[] args) {
        Apple<Integer> ai = new Apple<>();
        Apple<Double> ad = new Apple<>();
        Apple<String> as = new Apple<>(); // 编译出错，试图将 String 类型传给 T 形参，但是 String 不是 Number 的子类型
    }
}

泛型方法

定义

泛型方法就是在声明方法时定义一个或多个类型形参。多个类型参数之间用逗号隔开。

修饰符 <T, S> 返回值类型 方法名(形参列表) {方法体}

需求分析

泛型方法解决了什么问题？

static void fromArrayToCollection(Object[] a, Collection<Object> c) {
    for (Object o : a) {
        c.add(o)
    }
}

上面定义的方法没有任何问题，关键在于方法中的 c 形参，它的数据类型是 Collection<Object>。假设传入的实际参数的类型是 Collection<String>，因为 Collection<String> 并不是 Collection<Object> 的子类，所以这个方法的功能非常有限，它只能将 Object[] 数组的元素复制到元素为 Object 类型（Object 的子类不行）的 Collection 集合中。

如果使用通配符 Collection<?> 是否可行呢？显然也不行，Collection 集合提供的的 add() 方法中有类型参数 E，而如果使用类型通配符，这样程序无法确定 c 集合中的元素类型，所以无法正确调用 add 方法。

问题解决

泛型方法。

import java.util.ArrayList;
import java.util.Collection;

public class GenericMethodTest {
    // 声明一个泛型方法
    static <T> void fromArryToCollection(T[] a, Collection<T> c) {
        for (T o : a) {
            c.add(o);
        }
    }
    public static void main(String[] args) {
        Object [] oa = new Object[100];
        Collection<Object> co = new ArrayList<>();
        fromArryToCollection(oa, co);

        String[] sa = new String[100];
        Collection<String> cs = new ArrayList<>();
        fromArryToCollection(sa, cs);
    }
}

进一步改造，如下

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

public class RightTest {
    static <T> void test(Collection<? extends T> from, Collection<T> to) {
        for (T ele : from) {
            to.add(ele);
        }
    }
    public static void main(String[] args) {
        List<String> as = new ArrayList<>();
        List<Object> ao = new ArrayList<>();
        test(as, ao);
    }
}

泛型构造器

和泛型方法类似，Java 也允许在构造器签名中声明类型形参，这就产生了所谓的泛型构造器

public class Foo {
    // 泛型构造器
    public <T> Foo(T t) {
        System.out.println(t);
    }
}

public class GenericConstructor {
    public static void main(String[] args) {
        new <String> Foo("crazy");
        new Foo("crazy"); // 与上面等价
        new <Sting> Foo(12.3) // 出错
    }
}

类型通配符下限

需求分析

实现一个方法，将 src 集合里的元素复制到 dest 集合里，且返回最后一个被复制的元素的功能。

因为 dest 集合可以保存 src 集合里的所有元素，所以 dest 集合元素的类型应该是 src 集合元素类型的父类。

为了表示两个参数间的类型依赖，考虑同时使用之前介绍过的通配符、泛型参数来实现该方法，代码如下：

public static <T> T copy(Collection<T> dest, Collection<? extends T> src) {
    T last = null;
    for (T ele : src) {
        last = ele;
        dest.add(ele);
    }
    return last;
}

List<Number> ln = new ArrayList<>();
List<Integer> li = new ArrayList<>();
// 下面代码会引起编译错误
Integer last = copy(ln, li);

上面的代码有一个问题，ln 的类型是 List<Number>，那么 T 的实际类型就是 Number，即返回值 last 类型是 Number 类型。但实际上最后一个复制元素的类型一定是 Integer。也就是说，程序在复制集合元素的过程中，丢失了 src 集合元素的类型。

问题解决

为了解决这个问题，引入通配符下限，<? super Type>。表示必须是 Type 本身或者 Type 的父类。改写后的完整代码，如下：

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

public class MyUtils {
    // 使用通配符下限
    public static <T> T copy(Collection<? super T> dest, Collection<T> src) {
        T last = null;
        for (T ele : src) {
            last = ele;
            dest.add(ele);
        }
        return last;
    }
    public static void main(String[] args) {
        List<Number> ln = new ArrayList<>();
        List<Integer> li = new ArrayList<>();
        li.add(5);
        // 此时可以准确知道最后一个被复制的元素是 Integer 类型，而不是笼统的 Number 类型
        Integer last = copy(ln, li);
        System.out.println(last);
        System.out.println(ln);
    }
}

泛型擦除

泛型基本上都是在编译器这个层次来实现的。在生成的 Java 字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数, 会被编译器在编译的时候去掉。这个过程就称为泛型擦除。如在代码中定义的 List<Object> 和 List<String> 等类型, 在编译之后都会变成 List, JVM 看到的只是 List, 泛型附加的类型信息对 JVM 来说是不可见的。

欢迎关注我的公众号