泛型程序设计
泛型，即“参数化类型”，将原来的具体类型参数化。在不创建新类型的情况下，通过泛型指定不同的类型形参，来控制实际传入实参的具体类型。换句话说，就是在使用和调用时传入具体的类型。
为什么使用泛型？
- 能够对类型进行限定（比如集合）
- 将运行期错误提前到编译期错误
- 获取明确的限定类型时无需进行强制类型转化
- 具有良好的可读性和安全性
泛型类
泛型类的定义
一个简单的泛型类，和普通类的区别是，类名后添加了<T>一个泛型标识，“T"类型参数（类型形参），传入的是类型实参，当然也可以用其他字母标识，但是"<>"左右尖括号必须存在。
public class Generic<T> {
private T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public static void main(String[] args) {
/* 1.没有传入具体的类型参数,可以存放任何类型的数据【下图】
* 本质:虚拟机会对泛型代码进行类型擦除,类型擦除后Generic<T>会变为
* Generic(原始类型),后面会讲到,无限定类型的域用Object代替,即擦除
* 后T data->Object data,这也是为什么没有传入具体类型,却能存放多种
* 类型的原因。
*/
Generic generic = new Generic();
generic.setData(1);
generic.setData("String");
generic.setData(new Object());
Generic genericStr = new Generic<String>();//CORRECT [1]
genericStr.setData("hello");
genericStr.setData(1);
/*
* 2.参数化类型(初始化时传入具体的类型参数)【下图】
* 本质:由编译器进行类型转化的处理,无需人为干预。
* 当调用泛型方法时,编译器自动在调用前后插入相应的
* 强转和调用语句。
*/
Generic<String> genericString=new Generic<>();
genericString.setData("hello");
//Generic<int> genericInt=new Generic<>(); ERROR [2]
Generic<Integer> genericInt=new Generic<>();
}
}
【1】原始类型可以接受任何参数化类型，即Generic generic == new Generic<String>()如[1]处所示。
【2】泛型的类型参数只能是类类型，不能是基本类型。如[2]处，但可以使用期包装类型。
【3】泛型参数命名规范如下：
泛型命名规范：国际惯例，类型参数的命名采用单个大写字母。
常见的泛型命名有：
T- Type：第一类通用类型参数。S- Type：第二类通用类型参数。U- Type：第三类通用类型参数。V- Type：第四类通用类型参数。E- Element：主要用于Java集合（Collections）框架使用。K- KeyV- ValueN- NumberR- Result
泛型接口
泛型接口的定义
和泛型类定义相似，如下：
public interface GenericInterface<T> {
T getData();
T setData(T data);
}
类接口的实现
类接口的实现存在三种形式，第一种无泛型，域类型用Object定义；第二种有泛型，域变量用泛型参数定义；第三种传递具体的类型参数，域变量的类型为具体的类型。
public class GenericInterfaceImpl implements GenericInterface {
@Override
public Object getData() {
return null;
}
@Override
public Object setData(Object data) {
return null;
}
}
/*
* 实现类的类型参数也需要声明，否则编译器会报错
*/
class GenericInterfaceImpT<T> implements GenericInterface<T> {
@Override
public T getData() {
return null;
}
@Override
public T setData(T data) {
return null;
}
}
/*
* 传入具体的类型实参
*/
class GenericInterfaceImplStr implements GenericInterface<String> {
@Override
public String getData() {
return null;
}
@Override
public String setData(String data) {
return null;
}
}
泛型方法
泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。
1、泛型方法的定义：类型变量放在修饰符前，返回类型的后面
# 修饰符 <T> 返回值 方法名(...);
* 示例
class ArrayAlg {
/*
*修饰符与返回值(T)中间的<T>标识此方法为泛型方法
*<T>表明该方法可以使用泛型类型T,可以在形参或者方法体中声明变量
/
public static <T> T getMiddle(T...a) {
return a[a.length/2];
}
}
2、调用泛型方法，在方法名前的尖括号放入具体的类型：
String middle = ArrayAlg.<String>getMiddle("John","Q","Public");
// 类型推断：类型参数可以省略 等同于
String middle = ArrayAlg.getMiddle("John","Q","Public");
使用泛型方法时，通常不需要指定参数类型，因为编译器会找出这些类型。 这称为 类型参数推断。
3、泛型方法辨别真假
/*
* 泛型类
* 注意：下面为了介绍，不把泛型方法归类到成员方法里，泛型方法是特指！
*/
public class GenericMethod<T> {
private T data;
/*
* [成员方法：非泛型方法]
* T getData()和setData(T data) 都不是泛型方法
* 他们只是类中的成员方法,只不过是方法的返回值类型
* 和方法的形参类型是用的泛型类上的T所声明的。
*/
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
/*
* [泛型方法]
* 泛型参数可以有多个，这里的T和泛型类上的T无任何关联，但是但是
* 它和泛型类上的参数类型变量相同，这时候idea会给予一个rename提示
*/
public <T,S> T genericMethod(S...a) {
return null;
}
/*
* [泛型方法]
* 使用泛型类上的泛型变量
* 这时候的T就和泛型类的类型相关了
*/
public <V> T genericMethod$1(T a, V b) {
return null;
}
/*
* [静态方法]
* 静态方法不能使用泛型类上的类型参数
* 如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法
*/
//public static T getDataStatic(T e) { } //ERROR [1]
/*
* [泛型方法]
* 静态泛型方法
*/
public static <E> E genericMethodS(E e) {
return e;
}
}
/*
*普通类中的泛型方法
*/
class OrdinaryClass {
public <T> void sayHello() {
T a;
//...
}
}
下面以苹果为例：
public class GenericClass<T> {
//成员方法，形参类型与泛型类的类型参数相关
public void print$1(T a) {
System.out.println(a.toString());
}
//下面三个都为泛型方法
//--begin
public <T> void print$2(T a) {
System.out.println(a.toString());
}
public <S> void print$3(S a) {
System.out.println(a.toString());
}
public static <T> void print$4(T a) {
System.out.println(a.toString());
}
//--end
public static void main(String[] args) {
Apple apple = new Apple();
MacBook macBook = new MacBook();
HongFuShi hongFuShi = new HongFuShi();
// 泛型类在初始化时限定了参数类型，成员方法中若使用泛型参数将会受限
GenericClass<Apple> genericCls = new GenericClass<>();
genericCls.print$1(apple);
//MacBook是apple的一个子类
genericCls.print$1(macBook);// OK
//由于初始化指定了泛型类型,print$1形参中的参数类型和泛型类的类型参数相关联
//所以，只能打印Apple及其子类
//genericCls.print$1(hongFuShi); ERROR
//泛型方法中的泛型变量类型与泛型类中的泛型参数没有任何关联
//所以说下面都能正常执行
genericCls.print$2(apple);
genericCls.<MacBook>print$2(macBook);//类型参数可以省略 [2]
genericCls.print$2(hongFuShi);
GenericClass.print$4(hongFuShi);
}
}
class Apple {
@Override
public String toString() {
return "Apple,Steve Jobs";
}
}
class MacBook extends Apple {
@Override
public String toString() {
return "MacBook";
}
}
class HongFuShi{
@Override
public String toString() {
return "HongFushi";
}
}
小结：
【1】泛型方法的标识：方法修饰符后返回值之前有"<...>"的声明。（判断是否为泛型方法）
【2】泛型方法可以定义在普通类中，也可以定义在泛型类中。
【3】静态方法不能使用泛型类上的类型参数，如[1]处
【4】成员方法中使用的参数类型和泛型类中的声明的类型参数有关联。
【5】泛型类中的参数类型与泛型方法中的参数类型的关联：泛型方法可以使用泛型类上的参数类型，这时候就与泛型类上的参数相关联；如果泛型方法中声明了与泛型类上相同的参数类型，那么优先使用泛型方法上的参数类型，这时候idea会给予一个rename提示。
【6】泛型方法的使用过程中,无需对类型进行声明,它可以根据传入的参数,自动判断。[2]
【7】方法中泛型参数不是凭空而来的，要么来自于泛型类上所定义的参数类型，要么来自于泛型方法中定义的参数类型。
泛型方法能独立于类而发生变化，所以说在使用原则上，在能达到目的的情况下,尽量使用泛型方法。即，如果使用泛型方法可以取代将整个类泛化，那么应该有限采用泛型方法。
类型变量的限定
对于类型变量没有限定的泛型类或方法， 它是默认继承自Object,当没有传入具体类型时,它有的能力只有Object类中的几个默认方法实现，原因就是类型擦除。
如果某个类实现Comparable接口中的compareTo方法，我们就可以通过compareTo比较两个值的大小。比如我们要计算数组中的最小元素：
public static void main(String[] args) {
// 传入 4 , 2 , 自动装箱成Integer类
int r = max(4, 2);
}
static <T> T min(T[] a) {
if (a == null || a.length == 0)
return null;
T smallest = a[0];
for (int i = 1; i < a.length; i++)
if (smallest.compareTo(a[i]) > 0)// ERROR，因为编译器不知道T声明的变量是什么类型
smallest = a[i];
return smallest;
}
如果没有对类型进行限定，它默认只有Object能力，变量smallest类型为T，编译器不知道他是否是实现了Comparable接口（是否是Comparable类型），所以可以通过将T限定为实现了Comparable接口的类，就可以解决这一问题。
对 类型参数进行限定,让它能够默认拥有一些类的"能力"。
static <T extends Comparable> T min(T[] a){...}
类型变量限定格式：<T extends BoundingType>
【1】T应该是绑定类型的子类型(subtype)。T和绑定类型可以是类，也可以是接口。
【2】一个类型变量或通配符可以有多个限定，限定类型用”&“分隔，类型变量用逗号分隔。例如：
<T extends Comparable & Serializable>;
<T,E extends Comparable & Serializable>;
【3】在 Java 的继承中， 可以拥有多个接口超类型， 但限定中至多有一个类。 如果用 一个类作为限定， 它必须是限定列表中的第一个。
<T extends ArrayList & LinkedList>;//ERROR，限定中至多有一个类
<T extends Comparable & LinkedList>;//ERROR，必须是限定列表中的第一个
<T extends ArrayList & Comparable>;//CORRECT
【4】类型限定不仅可以在泛型方法上，也可以在泛型类上，类型限定必须与泛型的声明在一起。
public <T extends Number> T compare(Generic<T extends Comparable> a) {..}//ERROR
public <T extends Number> T compare(Generic<T> a) {..}//ERROR
类型擦除
虚拟机没有泛型类型对象—所有对象都属于普通类。
类型擦除：无论何时定义一个泛型类型，都自动提供了一个相应的原始类型(raw type)。原始类型的名字就是删去类型参数后的泛型类型名。擦除（erased）类型变量，并替换为限定类型，如果没有给定限定就用Object替换。
例如，Holder的原始类型如下：
public class Holder {
private Object holder;
public Holder(Object holder) {
this.holder = holder;
}
public Object getHolder() {
return holder;
}
}
// 类型擦除也会出现在泛型方法中。
public static <T extends Comparable> T min(T[] a);
// 擦除类型之后，只剩下
public static Comparable min(Comparable[] a);
Java泛型 转换的事实：
- 虚拟机中没有泛型，只有普通的类和方法。
- 所有的类型参数都用它们的限定类型替换。
- 桥方法被合成来保持多态。
- 为保持类型安全性，必要时插入强制类型转换。
泛型的约束与局限
(1)不能用基本类型实例化类型参数
其原因是当类型擦除后，Object类型的域不能存储基本类型的值。
(2)所有的类型查询只产生原始类型
List<Number> numbers = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
System.out.println(numbers.getClass() == integers.getClass());//true
if (integers instanceof List){//true
System.out.println(true);
}
/*if (integers instanceof List<Integer>){//compile error
System.out.println(true);
}*/
(3)不能创建一个确切的泛型类型的数组
//List<Integer>[] lists = new ArrayList<Integer>[10];//ERROR
//可以声明原始类型创建数组，但是会得到一个警告
//可以通过@SuppressWarnings("unchecked")去除
List<Integer>[] list = new ArrayList[10];
//使用通配符创建泛型数组也是可以的，但是需要强制转换
List<Integer>[] listWildcard = (List<Integer>[])new ArrayList<?>[1];
下面采用通配符的方式是被允许的:数组的类型不可以是类型变量，除非是采用通配符的方式，因为对于通配符的方式，最后取出数据是要做显式的类型转换的。
List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li; // Correct.
Integer i = (Integer) lsa[1].get(0); // OK
(4)不能实例化类型变量
static <T> Object init(Class<T> cls) throws Exception {
//T a = new T(); // ERROR
// 注意不存在T.class.newInstance();
T t = cls.newInstance();//Class本身也是一个泛型类
return t;
}
(5)不能构造泛型数组
(6)泛型类的静态上下文中类型变量无效
(7)不能抛出或捕获泛型类的实例
不变 协变 逆变
首先看一段代码
Number[] n = new Integer[10];
ArrayList<Number> list = new ArrayList<Integer>(); // ERROR type mismatch
为什么Number类型的数组可以由Integer实例化，而ArrayList<Number>却不能被ArrayList<Integer>实例化呢？这就涉及到将要介绍的主题。
不变协变逆变的定义：
逆变与协变用来描述类型转换（type transformation）后的继承关系，其定义：如果AA、BB表示类型，f(⋅)表示类型转换，≤表示继承关系（比如，A≤B表示A是由B派生出来的子类）；
- f(⋅)是逆变（contravariant）的，当A≤B时有f(B)≤f(A)成立；
- f(⋅)是协变（covariant）的，当A≤B时有f(A)≤f(B)成立；
- f(⋅)是不变（invariant）的，当A≤B时上述两个式子均不成立，即f(A)与f(B)相互之间没有继承关系。
容易证明数组是协变的即Number[] n = new Integer[10];泛型是不变的,即使它的类型参数存在继承关系,但是整个泛型之间没有继承关系 : ArrayList<Number> list = new ArrayList<Integer>();
泛型类型的继承规则
1. 泛型参数是继承关系的泛型类之间是没有任何继承关系的。
在java中，Number是所有数值类型的父类，任何基本类型的包装类型都继承于它。
ArrayList<Integer> integers = new ArrayList<>();
ArrayList<Number> numbers = new ArrayList<>();
numbers = integers; // ERROR,就上上面刚刚提到的泛型是不变的
2. 泛型类可以扩展或实现其他的泛型类。这一点和普通类没有声明区别。比如ArrayList<T>类实现List<T>接口。这意味着，一个ArrayList<Integer>可以转换为一个List<Integer>（父类指向了子类的引用），但是，一个ArrayList<Integer>不是一个ArrayList<Number>或List<Number>(泛型参数继承与类无关）。
通配符
Java中引入通配符?来实现逆变和协变，通过通配符之前的操作也能赋值成功，如下所示：
List<? extends Number> number = new ArrayList<Integer>();// CORRECT
List<? super Number> list = new ArrayList<Object>();// CORRECT 逆变的代表
使用通配符的子类型关系
ArrayList<Integer>是ArrayList<? extends Number>的一个子类型。
通配符的分类
-
? extends T(上边界通配符 upper bounded wildcard)"?"是继承自T的任意子类型，表示一种约束关系。即泛型类型的范围不能超过T。
可以取元素，不能添加元素。
-
?（无限定通配符） -
? super T(下边界通配符 lower bounded wildcard)可以取元素，但是取出的元素是Object，可以添加元素，添加的元素，必须是T类或者其子类
记忆：上不存，下不取
示例：类型上边界通配符为什么只能添加？
ArrayList<Integer> integers = new ArrayList<>();
ArrayList<Object> objects = new ArrayList<>();
ArrayList<Number> nums = new ArrayList<>();
/*
* 1. 类型上边界通配符
* 对变量numbers赋值,引用的集合类型参数只能是Number或者其子类。
*/
ArrayList<? extends Number> numbers;
numbers = nums;
numbers = integers;
//引用的类对象类型超过了泛型类型的上边界
//numbers = objects; ERROR
integers.add(1);// 正常添加元素
//numbers.add(1); ERROR numbers只能读取,不能添加[1]
//但是可以添加null
numbers.add(null);
Number number = numbers.get(0);//可以读取元素
为什么只能读取，不能添加？[1]
？ extends T 表示类型的上界，类型参数是T的子类，那么可以肯定的说，get方法返回的一定是个T（不管是T或者T的子类）编译器是可以确定知道的。但是add方法只知道传入的是个T，至于具体是T的那个子类，不知道。
转化到本例来说就是：
理解方式一：
? extends Number指定类型参数必须是Number的子类,get方法返回的一定是Number
编译器确定，但是对于ArrayList的add方法为来说add(E e)->add(? extends Number e);
调用add函数不能够确定传入add的是Number的哪个子类型。编译器不确定。
理解方式二：
List是线性表吧【线性结构的存储】,线性表是n个具有相同类型的数据元素的有限序列。假若number能够add，因为? extends Number泛型通配符，可以添加Number的任何子类型，那么numbers在get时,极有可能引发ClassCastException,比如numbers引用了<Integer>,但是在索引0处却add了float类型的数据，取出的时候如果numbers.get(0).intValue();就会抛出异常。并且这也违背了线性表中特性,只能存放单一类型的元素。
/*
* 2. 类型下边界通配符
* numbersSuper所能引用的变量必须是Number或者其父类
*/
ArrayList<? super Number> numbersSuper;
numbersSuper = objects;// 逆变
numbersSuper = nums;
//限定了通配符的下界,类型最低是Number,Integer达不到
//下界,类型不匹配
//numbersSuper = integers; ERROR
numbersSuper.add(1); [2]
numbersSuper.add(2.0f); [3]
//numbersSuper.add(new Object()) ERROR
Object object = numbersSuper.get(0);
System.out.println(object);
？ super T 表示类型的下界，类型参数是T的超类（包括T本身）， 那么可以肯定的说，get方法返回的一定是个T的超类，那么到底是哪个超类？不知道，但是可以肯定的说，Object一定是它的超类，所以get方法返回Object。 编译器是可以确定知道的。对于add方法来说，编译器不知道它需要的确切类型，但是T和T的子类可以安全的转型为T。
为什么? super Number就可以add了呢？[2、3]
首先要明确的一点是，add的时候只能是Number[T]及其它的子类,不要和numberSuper只能引用Number的父类所混淆了。正因为numberSuper引用了<Object>,那么numberSuper在add的时候类型确定，都可以看作是Object类型，即Number的子类Integer和Float也是其Object的子类。但是相对于? extends T就add就不能调用，numbers如果限定了<Integer>，还是那句话，假若能放的话，number存放float类型的数据，取值时极易引发类型转化异常。
泛型方法和类型通配符
类型通配符所能解决的泛型方法一定也能解决
# 类型通配符
`public void func(List<? extends E> list);`
# 泛型方法
`public <T extends E> void func(List<T> list);`
* 上面两种方法可以达到同样的效果，两者的主要区别还是
i. 泛型对象是只读的，不可修改，因为?类型是不确定的，可以代表范围内任意类型；
ii. 而泛型方法中的泛型参数对象是可修改的，因为类型参数T是确定的（在调用方法时确定），因为T可以用范围内任意类型指定；
泛型方法和类型通配符（上界和下界）我们应该如何选择？
(1)泛型方法和通配符之间
修改最好使用泛型方法，在多个参数、返回值之间存在类型依赖关系就应该使用泛型方法，否则就应该使用通配符。
(2)什么时候用extends什么时候用super
PECS: producer-extends, consumer-super.
—《Effective Java》
- 要从泛型类取数据时，用extends
- 要往泛型类写数据时，用super
