泛型

泛型就是定义一种模板，既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型

泛型：编写模板代码来适应任意类型
（1）泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查
（2）使用泛型时，把泛型参数<T>替换为需要的class类型。ArrayList<String>、ArrayList<Number>等
注意泛型继承关系：可以把ArrayList<Integer>向上转型为List（T不变），但不能把ArrayList<Integer>向上转型为ArrayList<Number>（T不能变成父类）
可以省略编译器能自动推断出类型，例如：List<String> list = new ArrayList<>();（T省略）

（3）不指定泛型参数类型时，编译器会给出警告，且只能将视为Object类型
（4）可以在接口中定义泛型类型，实现此接口的类必须实现正确的泛型类型

（1）类型安全
泛型的主要目标是实现Java的类型安全。泛型可以使编译器知道一个对象的限定类型是什么，这样编译器就可以在一个高的程度上验证这个类型
（2）消除了强制类型转换，使得代码可读性好，减少了很多出错的机会

Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率

泛型实质
泛型实质：就是使程序员定义安全的类型
在没有出现泛型之前，Java也提供了对Object的引用“任意化”操作，这种任意化操作就是对Object引用进行“向下转型”及“向上转型”操作

定义泛型类

Object类为最上层的父类，通常为了使程序更为通用，设计程序时使传入的值与返回的值都以Object类型为主。以至于运行时将会发生ClassCastException异常

（1）编写泛型时，需要定义泛型类型<T>
（2）静态方法不能引用泛型类型<T>，必须定义其他类型（例如<K>）来实现静态泛型方法
（3）泛型可以同时定义多种类型。例如Map<K, V>

编写泛型类比普通类要复杂。通常来说，泛型类一般用在集合类中

类名<T>

T代表一个类型的名称

<T> T与T的区别

泛型	描述
<T> T	表示返回值是一个泛型，传递什么，就返回什么类型的数据
T	表示限制传递的参数类型

常规用法

定义泛型类时声明多个类型

MutiOverClass<T1,T2>

MutiOverClass：泛型类名称
T1、T2为可能被定义的类型，这样在实例化指定类型的对象时就可以指定多个类型

1.基本类型

按照某种类型：String，来编写类。然后，标记所有的特定类型（String）

public class Pair {
    private String first;
    private String last;
    public Pair(String first, String last) {
        this.first = first;
        this.last = last;
    }
    public String getFirst() {
        return first;
    }
    public String getLast() {
        return last;
    }
}

2.泛型类

将基本类型String替换为T

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

3.静态方法

特别注意：泛型类型<T>不能用于静态方法，会导致编译错误，无法在静态方法的方法参数和返回类型上使用泛型类型T
可以在static修饰符后面加一个<T>，编译就能通过，但实际上，这个<T>和Pair<T>类型的<T>已经没有任何关系了

public class Pair<T> {
	private T first;
	private T last;

	public Pair(T first, T last) {
		this.first = first;
		this.last = last;
	}

	// 可以编译通过:
	public static <T> Pair<T> create(T first, T last) {
		return new Pair<T>(first, last);
	}
}

对于静态方法，可以单独改写为“泛型”方法，只需要使用另一个类型即可。对于上面的create()静态方法，应该把它改为另一种泛型类型

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public T getLast() { ... }

    // 静态泛型方法应该使用其他类型区分:
    public static <K> Pair<K> create(K first, K last) {
        return new Pair<K>(first, last);
    }
}

这样才能清楚地将静态方法的泛型类型和实例类型的泛型类型区分开

4.多个泛型类型

泛型还可以定义多种类型。Pair类总是存储两个类型不一样的对象，就可以使用类型<T, K>

public class Pair<T, K> {
    private T first;
    private K last;
    
    public Pair(T first, K last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public K getLast() { ... }
}

使用的时候，需要指出两种类型

Pair<String, Integer> p = new Pair<>("test", 123);

Java标准库的Map<K, V>就是使用两种泛型类型的例子。它对Key使用一种类型，对Value使用另一种类型

擦拭法

（1）泛型是一种类似“模板代码”的技术，不同语言的泛型实现方式不一定相同
（2）Java语言的泛型实现方式是擦拭法（Type Erasure）
擦拭法：虚拟机对泛型其实一无所知，所有的工作都是编译器做的

编译时

1.编译器看到的代码

public class Pair<T> {
	private T first;
	private T last;

	public T getFirst() {
		return first;
	}

	public T getLast() {
		return last;
	}
}

2.虚拟机执行的代码

虚拟机根本不知道泛型

public class Pair {
    private Object first;
    private Object last;
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

也就是将<T>类型，转换为了Object

Java使用擦拭法实现泛型，导致
（1）编译器把类型<T>视为Object
（2）编译器根据<T>实现安全的强制转型

运行时

1.编译器写的代码

使用泛型的时候，编写的代码也是编译器看到的代码

Pair<String> p = new Pair<>("Hello", "world");
String first = p.getFirst();
String last = p.getLast();

2.虚拟机执行代码

而虚拟机执行的代码并没有泛型

Pair p = new Pair<>("Hello", "world");
String first = (String) p.getFirst();
String last = (String) p.getLast();

所以，Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动实行安全地强制转型

Java泛型的局限

Java泛型的实现方式（擦拭法），就知道了Java泛型的局限

局限一（不能是基本类型）

<T>不能是基本类型。例如int，因为实际类型是Object，Object类型无法持有基本类型

Pair<int> p = new Pair<>(1, 2); // compile error!

局限二（获取的Class实例都是同一个）

无法取得带泛型的Class

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
	}
}

Pair<String> p1 = new Pair<>("Hello", "world");
Pair<Integer> p2 = new Pair<>(123, 456);
Class c1 = p1.getClass();
Class c2 = p2.getClass();
System.out.println(c1==c2); // true
System.out.println(c1==Pair.class); // true

因为T是Object，对Pair<String>和Pair<Integer>类型获取Class时，获取到的是同一个Class，也就是Pair类的Class
换句话说，所有泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair<Object>

局限三（不能intanceof判断带泛型的Class）

无法判断带泛型的Class

Pair<Integer> p = new Pair<>(123, 456);
// Compile error:
if (p instanceof Pair<String>.class) {}

原因和前面一样，并不存在Pair<String>.class，而是只有唯一的Pair.class

局限四（不能实例化T类型）

不能实例化T类型

public class Pair<T> {
    private T first;
    private T last;
    
    public Pair() {
        // Compile error:
        first = new T();
        last = new T();
    }
}

上述代码无法通过编译，因为构造方法的两行语句

first = new T();
last = new T();

擦拭后实际上变成了：

first = new Object();
last = new Object();

这样一来，创建new Pair<String>()和创建new Pair<Integer>()就全部成了Object，显然编译器要阻止这种类型不对的代码

要实例化T类型，必须借助额外的Class<T>参数：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(Class<T> clazz) {
        first = clazz.newInstance();
        last = clazz.newInstance();
    }
}

上述代码借助Class<T>参数并通过反射来实例化T类型，使用的时候，也必须传入Class<T>

Pair<String> pair = new Pair<>(String.class);

因为传入了Class<String>的实例，所以借助String.class就可以实例化String类型

不恰当的覆写方法（需要避开与Object的冲突）

有些时候，一个看似正确定义的方法会无法通过编译

public class Pair<T> {
    public boolean equals(T t){
        return this == t;
    }
}

这是因为，定义的equals(T t)方法实际上会被擦拭成equals(Object t)，而这个方法是继承自Object的，编译器会阻止一个实际上会变成覆写的泛型方法定义
换个方法名，避开与Object.equals(Object)的冲突就可以成功编译

public class Pair<T> {
    public boolean same(T t) {
        return this == t;
    }
}

泛型继承

一个类可以继承自一个泛型类，使用的时候，因为子类IntPair并没有泛型类型，所以，正常使用即可

public class IntPair extends Pair<Integer> {}
IntPair ip = new IntPair(1 , 2);

在继承了泛型类型的情况下，子类可以获取父类的泛型类型。例如：IntPair可以获取到父类的泛型类型Integer

class Pair<T> {
	private T first;
	private T last;

	public Pair(T first, T last) {
		this.first = first;
		this.last = last;
	}

	public T getFirst() {
		return first;
	}

	public T getLast() {
		return last;
	}
}

class IntPair extends Pair<Integer> {
	public IntPair(Integer first, Integer last) {
		super(first, last);
	}
}

Class<IntPair> clazz = IntPair.class;
Type t = clazz.getGenericSuperclass();
if(t instanceof ParameterizedType) {
	ParameterizedType pt = (ParameterizedType) t;
	// 可能有多个泛型类型
	Type[] types = pt.getActualTypeArguments();
	// 取第一个泛型类型
	Type firstType = types[0];
	Class<?> typeClass = (Class<?>) firstType;
	System.out.println(typeClass); // Integer
}

Java的类型系统结构
在这里插入图片描述

（1）Java的泛型是采用擦拭法实现
（2）擦拭法决定了泛型<T>

条件	示例
①不能是基本类型	int
②不能获取带泛型类型的Class	Pair<String>.class
③不能判断带泛型类型的类型	x instanceof Pair<String>
④不能实例化T类型	new T()

（3）泛型方法要防止重复定义方法：public boolean equals(T obj)
（4）子类可以获取父类的泛型类型<T>

extends通配符（其子类或本身，下界）

<? extends Number>的泛型定义称之为上界通配符（Upper Bounds Wildcards），即把泛型类型T的上界限定在Number了，？代表的是Number或Number的子类

除了可以传入Pair<Integer>类型，我们还可以传入Pair<Double>类型，Pair<BigDecimal>类型等等，因为Double和BigDecimal都是Number的子类

class Pair<T> {
	private T first;
	private T last;

	public Pair(T first, T last) {
		this.first = first;
		this.last = last;
	}

	public T getFirst() {
		return first;
	}

	public T getLast() {
		return last;
	}
}

public static void main(String[] args) {
	Pair<Integer> p = new Pair<>(123, 456);
	int n = add(p);
	System.out.println(n);
}

static int add(Pair<? extends Number> p) {
	Number first = p.getFirst();
	Number last = p.getLast();
	return first.intValue() + last.intValue();
}

1.作用

如果考察Java标准库的java.util.List<T>接口，它实现的是一个类似“可变数组”的列表，主要功能包括

public interface List<T> {
    int size(); // 获取个数
    T get(int index); // 根据索引获取指定元素
    void add(T t); // 添加一个新元素
    void remove(T t); // 删除一个已有元素
}

2.限定T类型

定义泛型类型Pair<T>的时候，也可以使用extends通配符来限定T的类型

public class Pair<T extends Number> {}

非Number类型将无法通过编译

（1）使用类似<? extends Number>通配符作为方法参数时表示
方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst();；
方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。
即一句话总结：使用extends通配符表示可以读，不能写
（2）使用类似<T extends Number>定义泛型类时表示：泛型类型限定为Number以及Number的子类

super通配符（其父类或本身，下界）

Pair<? super Integer>表示，方法参数接受所有泛型类型为Integer或Integer父类的Pair类型

extends和super比较

	extends	super
作为方法参数	允许调用读方法T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）	允许调用写方法set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）

一个是允许读不允许写，另一个是允许写不允许读

PECS（Producer Extends Consumer Super）原则

如果需要返回T，它是生产者（Producer），要使用extends通配符；如果需要写入T，它是消费者（Consumer），要使用super通配符
总结出一条规律“Producer Extends，Consumer Super”：返回T（读）用extends，写入T（写）super
（1）“Producer Extends”：如果需要一个只读List，用它来Producer T，那么使用? extends T
（2）“Consumer Super”：如果需要一个只写List，用它来Consumer T，那么使用? super T
（3）如果需要同时读取以及写入，那么就不能使用通配符了

无限定通配符

<? extends T>和<? super T>作为方法参数的作用。实际上，Java的泛型还允许使用无限定通配符（Unbounded Wildcard Type），即只定义一个?

<?>通配符既没有extends，也没有super，因此：

（1）不允许调用set(T)方法并传入引用（null除外）
（2）不允许调用T get()方法并获取T引用（只能获取Object引用）
既不能读，也不能写，只能做一些null判断

（1）使用类似<? super Integer>通配符作为方法参数时表示
方法内部可以调用传入Integer引用的方法，例如：obj.setFirst(Integer n);；
方法内部无法调用获取Integer引用的方法（Object除外），例如：Integer n = obj.getFirst();。
即使用super通配符表示只能写不能读
（2）使用extends和super通配符要遵循PECS原则
（3）无限定通配符<?>很少使用，可以用<T>替换，同时它是所有<T>类型的超类