前言
为什么会引入泛型?
先看下面的例子:
private static int add(int a, int b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
private static float add(float a, float b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
private static double add(double a, double b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
发现没,在上面这个例子中,我们要实现不同类型的加法,则每种类型都需要重载一个add方法
再来看看使用泛型之后:
private static <T extends Number> double add(T a, T b) {
System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
return a.doubleValue() + b.doubleValue();
}
而通过泛型,我们可以将众多的add方法,复用为一个方法
泛型的意义
在这里我们就要说到泛型的意义了:
在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型,即代码复用
使用泛型还有没有其他好处呢?
再看看下面的例子:
例1:
List list = new ArrayList();
list.add("xxString");
list.add(100d);
list.add(new Person());
例2:
List<String> list = new ArrayList<String>();
// list中只能放String, 不能放其它类型的元素
在例1中,list中的元素由于没有指定泛型,默认为Object类型,所以在取出集合元素时需要人为的强制类型转化到具体的目标类型,且很容易出现java.lang.ClassCastException异常。
而在例2中,由于我们引入了泛型,list集合中的元素为指定的String类型,使用时则不需要强制类型转换,类型安全
泛型的基本使用
泛型有三种使用方式:泛型类、泛型接口、泛型方法
在这我们只说其中的一种,泛型方法
泛型方法
- 定义泛型方法语法格式
- 调用泛型方法语法格式
定义泛型方法时,必须在返回值前边加一个<T>,来声明这是一个泛型方法,持有一个泛型T,然后才可以用泛型T作为方法的返回值。
Class<T>的作用就是指明泛型的具体类型,而Class类型的变量c,可以用来创建泛型类的对象。
看到这里不知大家是否出现一个疑惑,为什么创建泛型对象要使用c.newInstance()?
由于是泛型方法,我们不知道具体类型是什么,因此我们没有办法去new一个对象,但可以利用变量c的newInstance方法去创建对象,即利用反射创建对象。
再接着说:
泛型方法要求的参数是Class类型,而Class.forName()方法的返回值也是Class,因此可以用Class.forName()作为参数。其中,forName()方法中的参数是何种类型,返回的Class就是何种类型。
在本例中,forName()方法中传入的是User类的完整路径,因此返回的是Class类型的对象,因此调用泛型方法时,变量c的类型就是Class,因此泛型方法中的泛型T就被指明为User,因此变量obj的类型为User。
泛型的上下限
再说泛型的上下限之前,先来看下面的一个例子
class A{}
class B extends A {}
// 如下两个方法不会报错
public static void funA(A a) {
// ...
}
public static void funB(B b) {
funA(b);
// ...
}
// 如下funD方法会报错
public static void funC(List<A> listA) {
// ...
}
public static void funD(List<B> listB) {
funC(listB);
// ...
}
大家可以想一想,为什么funB不会报错,funD()会报错呢?
想不通的小伙伴,可以将例子中的代码复制到idea中,在编译前的检查时,funC(listB)就报错了。
那么如何解决呢?
为了解决泛型中隐含的转换问题,Java泛型加入了类型参数的上下边界机制。<? extends A>表示该类型参数可以是A的子类类型。编译时擦除到类型A,即用A类型代替类型参数。这种方法可以解决开始遇到的问题,编译器知道类型参数的范围,如果传入的实例类型B是在这个范围内的话允许转换,这时只要一次类型转换就可以了,运行时会把对象当做A的实例看待
public static void funC(List<? extends A> listA) {
// ...
}
public static void funD(List<B> listB) {
funC(listB);
// ...
}
泛型的上限:
class Info<T extends Number>{ // 此处泛型只能是数字类型
private T var ; // 定义泛型变量
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
public String toString(){
// 直接打印
return this.var.toString() ;
}
}
public class demo1{
public static void main(String args[]){
Info<Integer> i1 = new Info<Integer>() ; // 声明Integer的泛型对象
}
}
泛型的下限:
class Info<T>{
private T var ; // 定义泛型变量
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
public String toString(){
// 直接打印
return this.var.toString() ;
}
}
public class GenericsDemo21{
public static void main(String args[]){
Info<String> i1 = new Info<String>() ; // 声明String的泛型对象
Info<Object> i2 = new Info<Object>() ; // 声明Object的泛型对象
i1.setVar("hello") ;
i2.setVar(new Object()) ;
fun(i1) ;
fun(i2) ;
}
public static void fun(Info<? super String> temp){
// 只能接收String或Object类型的泛型,String类的父类只有Object类
System.out.print(temp + ", ") ;
}
}
小结
<?> 无限制通配符
<? extends E> extends 关键字声明了类型的上界,表示参数化的类型可能是所指定的类型,或者是此类型的子类
<? super E> super 关键字声明了类型的下界,表示参数化的类型可能是指定的类型,或者是此类型的父类
// 使用原则《Effictive Java》
为了获得最大限度的灵活性,要在表示 生产者或者消费者 的输入参数上使用通配符,使用的规则就是:
生产者有上限、消费者有下限
1. 如果参数化类型表示一个 T 的生产者,使用 < ? extends T>;
2. 如果它表示一个 T 的消费者,就使用 < ? super T>;
3. 如果既是生产又是消费,那使用通配符就没什么意义了,因为你需要的是精确的参数类型。