泛型：为什么使用泛型与泛型的基本使用

1. 为什么使用泛型

泛型是 Java SE 1.5 的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
相对于传统上的形参，可以使我们的参数具有更多类型上的变化，使代码能更好地复用。

先看一段代码：

public class Box {
        private String value;

        public void set(String value) {
            this.value = value;
        }

        public String get() {
            return value;
        }
    }

普通定义的一个类，我们可以往类中设置一个 String 类型的数据。类很简单，使用也没什么问题。
但是，如果哪天我们又想有一个能设置 int 类型数据的类，这个时候我们可能会想，简单，继续加一个类，把 value 改为 int 类型的。
可是，业务不断膨胀，我们需要能设置更多数据类型的…
这时候，我们想着，还是设计一个通用点的类吧，于是想了想，做了下面的修改：

public class Box {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

Box 类中的参数定义为 Object 的，因此我们可以传入除基本类型以外的任意类型的数据。这样一改，通用性高了，也能满足我们的需求了，洋洋得意。
不要急，这里隐藏着一个很大的问题。

比如当如下使用时：

Box box = new Box();
box.set(6);
String result = (String) box.get();

传入的是一个 Integer (自动装箱) 类型的数据，但是可能由于在其他地方使用，或者是不同的人使用，不清楚具体是什么类型的数据，于是就强转为他需要的 String 类型，这时就会***抛出异常***。

Caused by: java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

这时，我们使用***泛型***来改造 Box 类：

public class Box<T> {
        private T t;

        public void set(T t) {
            this.t = t;
        }

        public T get() {
            return t;
        }
    }

使用时：

Box<Integer> box = new Box<>();
box.set(6);
String result = box.get(); //会直接报错，编译不通过

可以看到，这里只是把 Object 替换成了 T，我们依然可以传入除基础数据类型以外的任意类型数据，保持良好通用性的同时，也避免了上述隐藏的 Bug。

使用泛型的代码相比于没有使用泛型代码的好处：

• 在编译时，能有更强的类型检测

Java 编译器对泛型代码应用强类型检查，如果代码违反了类型安全性，就会发出错误。一般来说，修复一个编译时错误比修复运行时错误更加容易，因为后者更难发现。

• 消除强制类型转换

未使用泛型时，下面的代码需要强制类型转换：

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

使用泛型后，不再要强制类型转换：

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);

• 使程序员能够实现通用算法

通过使用泛型，程序员可以实现在不同类型集合上工作的泛型算法，可以自定义，并且类型安全，易于阅读。

2. 泛型的使用

泛型可以使用在类、接口、方法和非静态的成员变量上。
泛型指定的类型不能是基本类型(byte,short,int,long,float,double,char,boolean)。

泛型的命名

按照惯例，泛型参数名称是单个大写字母。这样命名的好处是容易和普通类、接口区分开。
关于泛型的一些通用命名方式：

• E : Element, 元素，Java 集合框架中广泛使用
• K ：Key
• V : Value
• N : Number
• T : Type
• S,U,V … : 第二，三，四…类型参数(Type)

调用和实例化

public class Box<T> {
        private T t;

        public void set(T t) {
            this.t = t;
        }

        public T get() {
            return t;
        }
    }

在泛型类 Box 使用时，我们需要将 T 替换为具体类型的值，比如 Integer。

Box<Integer> integerBox;

泛型类

参照上面的 Box 类。

泛型接口

public interface IBox<T> {
    void method(T t);
}

public class Box implements IBox {
    /**
     * 没有指定具体的类型，默认为object
     */
    @Override
    public void method(Object o) {
    }
}

public class Box implements IBox<String>{
    /**
     * s实现时指定具体的String类型
     */
    @Override
    public void method(String o) {
    }
}

public class Box<T> implements IBox<T>{
    /**
     * 实现时为指定类型，依然使用泛型T
     */
    @Override
    public void method(T o) {
    }
}

泛型方法

public class Box {

    /**
     *  定义泛型方法，只需将泛型参数列表置于返回值前
     */
    public<S> void x(S x) {
        System.out.println(x.getClass().getName());
    }

    /**
     * 静态方法也类似
     */
    public static <V> void y(V s) {
        System.out.println(s.getClass().getName());
    }

    public static void main(String[] args) {
        Box box = new Box();
        box.x(" ");
        box.x(10);
        box.x('a');
        box.x(box);

        Box.y(" ");
        Box.y(20);
        Box.y(box);
    }

}

多个泛型参数的使用

定义的接口中使用：

public interface Pair<K, V> {
    public K getKey();
    public V getValue();
}

OrderedPair 类实现该接口：

public class OrderedPair<K, V> implements Pair<K, V> {

    private K key;
    private V value;

    public OrderedPair(K key, V value) {
	this.key = key;
	this.value = value;
    }

    public K getKey()	{ return key; }
    public V getValue() { return value; }
}

实例化 OrderedPair 对象：

Pair<String, Integer> p1 = new OrderedPair<String, Integer>("Even", 8);
Pair<String, String>  p2 = new OrderedPair<String, String>("hello", "world");

上述代码中，new OrderedPair<String, Integer> 将 K 实例化为 String 类型，将 V 实例化为 Integer 类型。由于自动装箱，可以直接传入一个 String 和 int 参数 ("Even", 8)。

在 Java SE 7 及以后的版本，编译器能自动判断 K、V 的类型，所以上述代码可以简写为：

OrderedPair<String, Integer> p1 = new OrderedPair<>("Even", 8);
OrderedPair<String, String>  p2 = new OrderedPair<>("hello", "world");

参照:

Why Use Generics?
Generic Types