java泛型

前言

为什么会引入泛型？

先看下面的例子：

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. 如果既是生产又是消费，那使用通配符就没什么意义了，因为你需要的是精确的参数类型。