Java中泛型的应用-蒲公英云

Java中泛型的定义

在程序编码中一些包含类型参数的类型，也就是说泛型的参数只可以代表类，不能代表个别对象。（这是当今较常见的定义）

在程序编码中一些包含参数的类。其参数可以代表类或对象等等。

不论使用那个定义，泛型的参数在真正使用泛型时都必须作出指明。

泛型的实例

泛型类

有许多原因促成了泛型的出现，而最引人注意的一个原因，就是为了创建容器类。

容器类应该算得上最具重用性的类库之一。先来看一个没有泛型的情况下的容器类如何定义：

public class Container {
    private String key;
    private String value;
    public Container(String k, String v) {
        key = k;
        value = v;
    }
    public String getKey() {
        return key;
    }
    public void setKey(String key) {
        this.key = key;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
}

Container类保存了一对key-value键值对，但是类型是定死的，也就说如果我想要创建一个键值对是String-Integer类型的，当前这个Container是做不到的，必须再自定义。那么这明显重用性就非常低。

当然，我可以用Object来代替String，并且在Java SE5之前，我们也只能这么做，由于Object是所有类型的基类，所以可以直接转型。但是这样灵活性还是不够，因为还是指定类型了，只不过这次指定的类型层级更高而已，有没有可能不指定类型？有没有可能在运行时才知道具体的类型是什么？

所以，就出现了泛型。

public class Container<K, V> {
    private K key;
    private V value;
    public Container(K k, V v) {
        key = k;
        value = v;
    }
    public K getKey() {
        return key;
    }
    public void setKey(K key) {
        this.key = key;
    }
    public V getValue() {
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
}

在编译期，是无法知道K和V具体是什么类型，只有在运行时才会真正根据类型来构造和分配内存。可以看一下现在Container类对于不同类型的支持情况：

public class Main {
    public static void main(String[] args) {
        Container<String, String> c1 = new Container<String, String>("name", "findingsea");
        Container<String, Integer> c2 = new Container<String, Integer>("age", 24);
        Container<Double, Double> c3 = new Container<Double, Double>(1.1, 2.2);
        System.out.println(c1.getKey() + " : " + c1.getValue());
        System.out.println(c2.getKey() + " : " + c2.getValue());
        System.out.println(c3.getKey() + " : " + c3.getValue());
    }
}

输出：

name : findingsea
age : 24
1.1 : 2.2

泛型接口

在泛型接口中，生成器是一个很好的理解，看如下的生成器接口定义：

public interface Generator<T> {
    public T next();
}

然后定义一个生成器类来实现这个接口：

public class FruitGenerator implements Generator<String> { 
    private String[] fruits = new String[]{
   "Apple", "Banana", "Pear"};
    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

调用：

public class Main {
    public static void main(String[] args) {
        FruitGenerator generator = new FruitGenerator();
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
    }
}

输出：

Banana
Banana
Pear
Banana

泛型数组

public class GenericsDemo30{   
    public static void main(String args[]){  
        Integer i[] = fun1(1,2,3,4,5,6) ;   // 返回泛型数组 
        fun2(i) ;  
    }   
    public static <T> T[] fun1(T...arg){  // 接收可变参数 
        return arg ;            // 返回泛型数组 
    }  
    public static <T> void fun2(T param[]){   // 输出 
        System.out.print("接收泛型数组：") ;  
        for(T t:param){  
            System.out.print(t + "、") ;  
        }  
    }  
}

泛型方法

一个基本的原则是：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛化，那么应该有限采用泛型方法。下面来看一个简单的泛型方法的定义：

定义泛型方法

public class Main {
    public static <T> void out(T t) {
        System.out.println(t);
    }
    public static void main(String[] args) {
        out("findingsea");
        out(123);
        out(11.11);
        out(true);
    }
}

可以看到方法的参数彻底泛化了，这个过程涉及到编译器的类型推导和自动打包，也就说原来需要我们自己对类型进行的判断和处理，现在编译器帮我们做了。这样在定义方法的时候不必考虑以后到底需要处理哪些类型的参数，大大增加了编程的灵活性。

再看一个泛型方法和可变参数的例子：

public class Main {
    public static <T> void out(T... args) {
        for (T t : args) {
            System.out.println(t);
        }
    }
    public static void main(String[] args) {
        out("findingsea", 123, 11.11, true);
    }
}1

输出和前一段代码相同，可以看到泛型可以和可变参数非常完美的结合。

通过泛型方法返回泛型类的实例

class Info<T extends Number>{ // 指定上限，只能是数字类型 
    private T var ;     // 此类型由外部决定 
    public T getVar(){  
        return this.var ;     
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public String toString(){       // 覆写Object类中的toString()方法 
        return this.var.toString() ;      
    }  
}  
public class GenericsDemo27{  
    public static void main(String args[]){  
        Info<Integer> i = fun(30) ;  
        System.out.println(i.getVar()) ;  
    }  
    public static <T extends Number> Info<T> fun(T param){  
        Info<T> temp = new Info<T>() ;      // 根据传入的数据类型实例化Info 
        temp.setVar(param) ;        // 将传递的内容设置到Info对象的var属性之中 
        return temp ;   // 返回实例化对象 
    }

使用泛型统一传入参数的类型

class Info<T>{    // 指定上限，只能是数字类型 
    private T var ;     // 此类型由外部决定 
    public T getVar(){  
        return this.var ;     
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public String toString(){       // 覆写Object类中的toString()方法 
        return this.var.toString() ;      
    }  
}
public class GenericsDemo28{  
    public static void main(String args[]){  
        Info<String> i1 = new Info<String>() ;  
        Info<String> i2 = new Info<String>() ;  
        i1.setVar("HELLO") ;        // 设置内容 
        i2.setVar("李兴华") ;      // 设置内容 
        add(i1,i2) ;  
    }  
    public static <T> void add(Info<T> i1,Info<T> i2){  
        System.out.println(i1.getVar() + " " + i2.getVar()) ;  
    }  
}

泛型嵌套

Demo类中的info属性是Info类的这种属性，Info类本身需要两个泛型。

class Info<T,V>{       // 接收两个泛型类型 
    private T var ;  
    private V value ;   
    public Info(T var,V value){  
        this.setVar(var) ;  
        this.setValue(value) ;  
    }   
    public void setVar(T var){  
        this.var = var ;  
    }   
    public void setValue(V value){  
        this.value = value ;  
    }   
    public T getVar(){  
        return this.var ;  
    }   
    public V getValue(){  
        return this.value ;  
    }  
} 
class Demo<S>{   
    private S info ;  
    public Demo(S info){  
        this.setInfo(info) ;  
    }  
    public void setInfo(S info){  
        this.info = info ;  
    }   
    public S getInfo(){  
        return this.info ;  
    }  
}
public class GenericsDemo31{  
    public static void main(String args[]){  
        Demo<Info<String,Integer>> d = null ;       // 将Info作为Demo的泛型类型 
        Info<String,Integer> i = null ;   // Info指定两个泛型类型 
        i = new Info<String,Integer>("李兴华",30) ;   // 实例化Info对象 
        d = new Demo<Info<String,Integer>>(i) ; // 在Demo类中设置Info类的对象 
        System.out.println("内容一：" + d.getInfo().getVar()) ;  
        System.out.println("内容二：" + d.getInfo().getValue()) ;  
    }  
}