标签：
泛型出现的动机在于：为了创建容器类
容器类应该算得上最具重用性类库之一。先来看一下没有泛型的情况下的容器类如何定义：
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类型的，当前这个容器做不到的，必须再自定义。那么这明显重用性就非常低。
当然，可以用Object来代替String，并且在javaSE5之前，我们也只能这么做，由于Object是所有类型的基类，所以可以直接转型。但是这样灵活性还是不够，因为还是指定了类型，只不过这次指定的类型层级
更高而已，有没有可能不指定类型？有没有可能在运行时才知道具体的类型是什么？
so，就出现了泛型。
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", "gudoumaoning"); Container<String Integer> c1 = new Container<String, Integer>("age", "24"); Container<Double Double> c1 = new Container<Double, Integer>(1.2, 1.3); System.out.println(c1.getKey() + ":" + c1.getValue()); System.out.println(c2.getKey() + ":" + c2.getValue()); System.out.println(c3.getKey() + ":" + c3.getValue()); } }
//输出：
name : gudoumaoning
age : 24
1.2 : 1.3
在泛型结构中，生成器是一个很好的理解，看如下的生成器接口定义：
public interface Generator<T> { public T next(); }
public class FruiteGenerator implements Generator<String> { private String[] fruite = 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) { FruiteGenerator fruitegenerator = new FruiteGenerator(); System.out.println(fruitegenerator.next()); System.out.println(fruitegenerator.next()); System.out.println(fruitegenerator.next()); System.out.println(fruitegenerator.next()); } }
//输出：
apple
pear
pear
banana
一个基本原则是：无论何时，只要你能做到，你就尽量使用泛型方法。也就是说，如果泛型方法可以取代将整个类泛化，那么应该有限采用泛型方法。下面来看一个简单的泛型方法的定义：
public class Main { public static <T> void out(T t) { System.out.println(t); } public static void main (String[] args) { out("gudoumaoning"); out(123); out(11.11); out(false); } }
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("gudoumaoning", 123, 11.11, false); } }
输出和前一段代码相同，可以看到泛型可以和可变参数完美结合。
标签：
原文地址：http://www.cnblogs.com/guDouMaoNing/p/4392404.html
