java中的泛型设计

1.为什么要使用泛型程序设计
ArrayList<String> files = new ArrayList<>() 等价于 var files = new ArrayList<String>()

2.定义简单泛型类
public class Pair<T>{
private T first;
private T second;
public Pair(){first = null; second = null;}
public Pair(T first, T second){this.first = first; this.second = second;}
public T getFirst(){return first;}
public void setFirst(T newValue){first = newValue;}
泛型类后面可以有多个类型变量如 public class pair<T, U>{}

3.泛型方法
可以在普通类中定义泛型方法类型变量放在修饰符后面(public static) 在返回类型的前面(T) 如
class ArrayAlg{
public static <T> T getmiddle(T... a){
return a[a.length / 2];
}
}
当你调用一个泛型方法时可以把具体类型放在尖括号中放在方法名前面如
String middle = ArrayAlg.<String>getmiddle("John", "Q", "Public");
也可以不写具体类型编译器会自动推断如
String middle = ArrayAlg.getmiddle("John", "Q", "Public");

4.类型变量的限定
class ArrayAlg{
public 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) smallest = a[i];
return smallest;
}
}
注意这里的min方法中 smallest的类型为T 而T必须是实现了Comparable接口的类可以通过对T设置一个限定来实现如
public static <T extends Comparable> T min(T[] a){}
类型变量的限定格式：<T extends BoundingType>
一个类型变量或通配符可以有多个限定限定类型用"&"分隔而逗号用来分隔类型变量如 T extends Comparable & Serializable
为了提高效率应将标签接口(即没有方法的接口)放在限定列表的末尾

5.泛型代码与虚拟机(仅需了解原理即可)
虚拟机没有泛型类型对象所有对象都属于普通类
1.类型擦除：无论何时定义一个泛型类型都会自动提供一个相应的原始类型这个原始类型的名字就是去掉类型参数<T>的泛型类型名
类型变量 T 会被擦除并替换为其限定类型(对于无限定的变量则替换为Object)
原始类型用第一个限定来替换类型变量T 若没有给定限定就替换为Object
如：public class Interval<T extends Comparable & Serializable> implements Serializable{
private T lower;
}
在虚拟机中类型擦除后为：public class Interval implements Serializable{
private Comparable lower;
}
2.转换泛型表达式：编写一个泛型方法调用时如果擦除了返回类型编译器会插入强制类型转换如下：
对于这个语句序列：
Pair<Employee> buddies = ...;
Employee buddy = buddies.getFirst();
getFirst擦除类型后的返回类型为Object 编译器自动插入了转换到Employee的强制类型转换
3.转换泛型方法：类型擦除也会出现在泛型方法中但是可能引发一些多态的问题虚拟机是如何解决的呢？
如：class DateInterval extends Pair<LocalDate>{
public void setSecond(LocalDate Second){
if(Second.compareTo(getFirst()) >= 0)
super.setSecond(second);
}
}
这个类进行擦除后变为class DateInterval extends Pair{
public void setSecond(LocalDate Second){ ...}
}
然而还有一个从Pair继承来的setSecond方法即public void setSecond(Object Second)
考虑下面的语句序列：
var interval = new DateInterval( ...);
Pair<LocalDate> pair = interval;
pair.setSecond(aDate);
那么调用时会调用哪个呢？
实际上编译器会在类中生成一个桥方法 public void setSecond(Object Second){setSecond((LocalDate) second);}
通过桥方法会调用setSecond((LocalDate) second 这样就实现了多态
总之对于java泛型的转换需要记住以下几个事实：
虚拟机中没有泛型只有普通的类和方法
所有的类型参数都会体会为它们的限定类型
会合成桥方法来保持多态
为保持类型安全性必要时会插入强制类型转换
4.调用遗留代码：可用注解 @SuppressWarnings("unchecked") 消除警告这个注解会关闭对接下来语句的检查

6.限制与局限性：
1.不能用基本类型来实例化类型参数
类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）
如没有Pair<double> 只能用Pair<Double> 即基本类型使用时需要使用他们的包装类
2.运行时类型查询只适用于原始类型
所有的类型查询都返回原始类型如 instanceof检查和getClass方法对于Pair<T>的检查都返回Pair
3.不能创建参数化类型的数组
不能实例化参数化类型的数组如 var table = new Pair<String>[10]是错误的
虽然不允许创建这些数组但声明类型为Pair<String>[]的变量仍是合法的不过不能用new Pair<String>[10]初始化这个变量
可以声明通配符类型的数组然后强转如 var table = (Pair<String>[]) new Pair<?>[10]; 这样虽然能通过但是是不安全的建议不用
如果需要收集参数化类型对象简单的使用ArrayList：ArrayList<Pair<String>>更安全有效
4.Varargs警告
public static <T> void addAll(Collection<T> coll, T... ts){
for(T t : ts) coll.add(t);
}
Collection<Pair<String>> table = ...;
Pair<String> pair1 = ...;
Pair<String> pair2 = ...;
addAll(table, pair1, pair2);
为了调用这个方法 java虚拟机必须建立一个Pair<String>数组但是虚拟机只会给你提供一个警告而不是错误
可用两种方法来抑制这个警告一种是为addAll方法增加注解@SuppressWarnings("unchecked") 另一种是用@SafeVarargs直接注解addAll方法
5.不能实例化类型变量
不能在类似new T(...)的表达式中使用类型变量如 public Pair(){first = new T();}就是非法的
在java8之后最好的解决办法是让调用者提供一个构造器表达式如
Pair<String> p = Pair.makePair(String::new);
makePair方法接收一个Supplier<T> 这是一个函数式接口表示一个无参数而且返回类型为T的函数
public static <T> Pair<T> makePair(Supplier<T> constr){
return new Pair<>(constr.get());
传统方法是通过反射调用Constructor.newInstance方法来构造泛型对象
public static <T> Pair<T> makePair(Class<T> cl){
try{
return new Pair<>(cl.getConstructor().newInstance());
}
catch(Exception e){return null;}
}
这个方法可以如下调用
Pair<String> p = Pair.makePair(String.class)
注意 Class类本身是泛型的因此 makePair方法能够推断出Pair的类型
6.不能构造泛型数组
直接构造并强制转换会出现异常最好让用户提供一个数组构造器表达式如
String[] names = ArrayAlg.minmax(String[]::new, "Tom", "Dick", "Harry");
public static <T extends Comparable> T[] minmax(IntFunction<T[]> constr, T... a){
T[] result = constr.apply(2);
......
}
比较老式的办法是利用反射并调用Array.newInstance:
public static <T extends Comparable> T[] minmax(T... a){
var result = (T[]) Array.newInstance(a.getClass().getComponentType(), 2);
......
}
7.泛型类的静态上下文中类型变量无效
不能再静态字段或静态方法中引用类型变量！
8.不能抛出或捕获泛型类的实例
既不能抛出也不能捕获泛型类的对象如不能扩展Throwable类(一个泛型类) catch子句中也不能使用类型变量如
public class Problem<T> extends Exception{...}是不合法的
9.可以取消对检查型异常的检查
可使用以下方法将所有异常都转化为编译器所认为的非检查型异常
@SuppressWarnings("unchecked")
static <T extends Throwable> void throwAs(Throwable t) throws T{
throw(T) t;
}
假设这个方法包含在接口Task中如果有一个检查型异常e 可使用如下代码
try{
......
}
catch(Throwable t){
Task.<RuntimeException>throwAs(t);
}
10.注意擦除后的冲突
注意不要和擦除后的Object中的方法同名擦除后会引起冲突
不允许实现对同一接口的不同参数化可能会引起桥方法的冲突

7.泛型类型的继承规则：
无论S与T有什么关系(如S是T的子类或原始类型等等) Pair<S>与Pair<T>都没有任何关系

8.通配符类型
1.通配符概念
在通配符类型中允许类型参数发生变化如 Pair<? extends Employee>表示任何泛型Pair类型它的类型参数是Employee的子类
如 public static void printBuddies(Pair<Employee> p){} 不能将Pair<Manager>传递给这个方法不过可以使用一个通配符类型
public static void printBuddies(Pair<? extends Employee> p) 类型Pair<Manager>是Pair<? extends Employee>的子类型
不能调用setFirst方法因为无法知道具体是什么类型但是可以调用getFirst方法
2.通配符的超类型限定
? super Manager 这个通配符限制为Manager的所有超类型
与上一个相反这种可以为方法提供参数但不能使用返回值即可以用setFirst 但不能用getFirst
直观的讲带有超类型限定的通配符允许你写入一个泛型对象而带有子类型限定的通配符允许你读取一个泛型对象
3.无限定通配符
Pair<?> 此时 getFirst的返回值只能赋给一个Object setFirst方法不能被调用甚至不能用Object调用
Pair<?>与Pair本质的不同在于：可以用任意Object对象调用原始Pair类的setFirst方法
这种类型可能对一些简单操作非常有用如测试一个对组是否包含一个null引用如下
public static boolean hadNulls(Pair<?> p){
return p.getFirst() == null || p.getSecond() == null;
}
4.通配符捕获
public static void swap(Pair<?> p) 注意不能再编写代码中用？作为一种类型那怎么实现这个方法呢？
可以写一个辅助方法swapHelper 再被上面的方法调用即可这就是捕获通配符
public static <T> void swapHelper(Pair<T> p){
T t = p.getFirst();
p.setFirst(p.getSecond());
p.setSecond(t);
}
这时可由swap调用swapHelper 如public static void swap(Pair<?> p){swapHelper(p)}
在这种情况下swapHelper中的参数T捕获通配符
注意：编译器必须保证通配符表示单个确定的类型例如 ArrayList<Pair<T>>中的T永远不能捕获ArrayList<Pair<?>>中的通配符

巴特西

java中的泛型设计

最新文章

热门文章