Java—泛型详解和使用

1 泛型介绍

1.1 泛型的出现

  泛型的出现还得从集合说起，没有泛型的时候，我们将一个对象存入集合时，集合不care这个对象的数据类型是什么，当我们再次从这个对象取出来的时候，对象的编译类型会变成Object类型，这时候我们就需要强制类型转换，但是这种行为每次都要去指定类型进行强制转换，并且有可能强制转换不了，比如我存的是Integer类型，误转换为String类型，那就可能会引发ClassCastException异常。
  当Java 5引入了一个叫做“参数化类型”的概念后，我们可以在创建集合时去指定集合，这样我们再从集合取出数据时，这个数据就是我们当初指定的类型，不会出现需要强制类型转换的情况了。这种参数化类型就是泛型。

1.2 泛型在集合中的使用示例

  在集合接口或者类后面增加尖括号<>，里面注明数据类型，创建这个集合后，这个集合就只能存储这个特定的数据类型对象。
  从Java 7开始，在使用带泛型的接口、类定义变量，我们调用构造器创建对象时构造器后面不需要带完整的泛型信息，只需要带一对尖括号<>就行。如List<String> strList = new ArrayList<>();只需要前面声明<String>泛型，后面只需要<>即可。
示例：

public class DemoApplication {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        stringList.add("t1");
        stringList.add("t11");
        Map<String, List<String>> map = new HashMap<>();
        map.put("t", stringList);
        stringList.forEach(str -> System.out.println(str.length()));
        map.forEach((key, value) -> System.out.println(key + "---->" + value));
    }
}

结果：

2
3
t---->[t1, t11]

2 泛型的进阶

  泛型就是允许在定义接口、类和方法时使用类型形参，通过传入实际的类型参数（类型实参），该类型形参会在声明变量、创建对象、调用方法的时候动态指定。类型形参可以在整个接口、类内当作类型使用。这种方式可以动态生成无限个逻辑上的子类（实际物理中没有）。
  无论泛型的类型形参传入的是什么类型实参，系统最后都是当作一个类来处理，内存中也只是占用一块内存空间。如List<Integer> intList = new ArrayList<>();和List<String> strList = new ArrayList<>();通过intList.getClass()和strList.getClass()得到的是相等的结果，这就表明两个类是相同的。

另： 在静态变量和静态方法声明中不可以使用类型形参。

2.1 泛型接口举例

public interface List<T> {
	void create(T e);
	void delete(T e);
	void update(T e);
	void find(T e);
}

其中，List为例，若形参T传入的是String类型的实参，则会产生一个List<String>，逻辑上是List的子接口，只不过这个接口内的E类型都为String类型。

2.2 泛型类举例

定义泛型类Person：

//创建带泛型声明的自定义类
public class Person<T>{

    //使用T类型形参来定义实例变量
    private T info;

    public Person(){}

    //使用T类型形参定义构造器，注意：构造器不用增加泛型声明，直接使用原类名即可；
    public Person(T info) {
        this.info = info;
    }

    public T getInfo() {
        return info;
    }

    public void setInfo(T info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return info.toString();
    }
}

泛型形参传入实参测试：

public class DemoApplication {
    public static void main(String[] args) {
    	
    	//实参传入String类型给T形参，则构造器构造对象时传参为String类型；
		Person<String> personStr = new Person<>("小明");
        System.out.println("姓名: " + personStr.getInfo());
        
    	//实参传入Integer类型给T形参，则构造器构造对象时传参为Integer类型；
        Person<Integer> personInt = new Person<>(28);
        System.out.println("年龄: " + personInt.getInfo());
	}
}

结果：

姓名: 小明
年龄: 28

从上面的实验中，我们可以看出：通过泛型类Person<T>传入实参后，可以生成诸如Person<String>，Person<Integer>，Person<Float>等多个逻辑子类。

2.3 泛型类无参子类

创建ChinesePerson类继承无参泛型类。

public class ChinesePerson extends Person {
    @Override
    public String getInfo() {
        return super.getInfo().toString();
    }
}

测试：

public class DemoApplication {
    public static void main(String[] args) {
    
        Person<String> chinesePerson = new ChinesePerson();
        chinesePerson.setInfo("中国人");

        System.out.println("Chinese person: " + chinesePerson.getInfo());
	}
}

结果：

Chinese person: 中国人

2.5 泛型类带参子类

创建JiangsuPerson类继承带参泛型类。

public class JiangsuPerson extends Person<String> {
    //重写父类方法，返回值类型需保持一致
    public String getInfo() {
        return "城市信息： " + super.getInfo();
    }
}

测试：

public class DemoApplication {
    public static void main(String[] args) {

        Person<String> jiangsuPerson = new JiangsuPerson();
        jiangsuPerson.setInfo("南京");
        System.out.println(jiangsuPerson.getInfo());

	}
}

结果：

城市信息： 南京

3 泛型的类型通配符

3.1 类型通配符<?>

  通配符?在类型形参中使用后，可以表示各种泛型的父类，如List<?>，即List的类型未知，可以传入任何类型的实参。
  这种List<?>不能直接添加元素，因为无法确定集合内的类型是什么，所以无法添加对象。（除了null，因为null是所有引用类型的实例）
  List<?>通过get()方法返回的一定是Object，所以可以将其赋值给Object类型变量。

3.2 类型通配符上限<? extends xx>

  通过<? extends xx>表示所有xx泛型的父类，如List<? extends Person>表示所有Person泛型List的父类。?代表的是一个未知类型，但这个未知类型又受到extends限制，只能是Person的自身及子类。

3.3 类型形参的上限

  类型形参的上限主要是限制实参只能是形参类型本身或子类。
示例：

public class Person<T extends Number> {
	T info;
	public static void main(String[] args) {
		Person<Integer> person = new Person<>();
		Person<Float> person2 = new Person<>();
	}
}

若上述代码中增加Person<String> person3 = new Person<>();，则编译报错，因为String类型不是Number或子类；通过<T extends xx>限制住形参的上限。

4 泛型方法

4.1 泛型方法定义

  泛型方法就是在声明方法时定义一个或多个类型形参；相比较于普通方法，泛型方法多了类型形参声明，多了<>，若有多个类型形参，使用逗号","隔开，并且在方法修饰符和方法返回值类型中间要有类型形参。

4.2 语法

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

4.3 举例

泛型方法：

public class GenericMethodExample {
    //定义泛型方法，传递T类型形参
    public static <T> void copyArrayToCollection(T[] array, Collection<T> collection) {
        for (T obj : array) {
            collection.add(obj);
        }
    }

    //定义泛型方法，通过类型通配符设置T类型上限
    public static <T> void copyCollectionToCollection(Collection<? extends T> fromCollection,
                                                      Collection<T> toCollection) {
        for (T obj : fromCollection) {
            toCollection.add(obj);
        }
    }
}

入口类：

public class DemoApplication {
    public static void main(String[] args) {
		//泛型方法
        Object[] objects = new Object[]{"10", 12, new Person("hello, i'm from jiangsu")};
        Collection<Object> collections = new ArrayList<>();
        GenericMethodExample.copyArrayToCollection(objects, collections);
        collections.forEach(obj -> System.out.println(obj.toString()));
        
        //泛型方法通过类型通配符设置上限类型形参
        List<Integer> fromCollection = new ArrayList<>();
        fromCollection.add(1);
        fromCollection.add(2);
        fromCollection.add(3);
        Collections.reverse(fromCollection);
        List<Number> toCollection = new ArrayList<>();
        GenericMethodExample.copyCollectionToCollection(fromCollection, toCollection);
        System.out.println("泛型方法上限测试：" + toCollection);
	}
}

运行结果：

10
12
hello, i'm from jiangsu
泛型方法上限测试：[3, 2, 1]

  从上述测试中，我们可以看到<T extends ?这种通配符设置类型形参上限，何时使用通配符，何时使用泛型方法？我们主要通过依赖关系来判断。如果方法中的一个或多个参数之间的类型是有依赖关系的，或者方法的返回值和参数类型有依赖关系，我们就使用泛型方法；反之，没有任何依赖关系的，我们就使用通配符去灵活的使用泛型。

5 泛型构造器

5.1 泛型构造器定义

  在构造器签名中声明类型形参就是泛型构造器。

5.2 语法

public <T> 类名（形参列表）{
	//方法体
}

5.3 示例

给GenericMethodExample类定义泛型构造方法

public class GenericMethodExample {
    
    public <T> GenericMethodExample(T t) {
        System.out.println(t);
    }
}

主类入口：

public class DemoApplication {
    public static void main(String[] args) {
        new GenericMethodExample("泛型构造器01");
        new GenericMethodExample(100);

        new <String> GenericMethodExample("显示指定泛型构造器形参T为String类型");
        new <Integer> GenericMethodExample(50);
	}
}

运行结果：

泛型构造器01
100
显示指定泛型构造器形参T为String类型
50

参考《疯狂Java》