关于java泛型

参考自http://blog.csdn.net/lonelyroamer/article/details/7864531

一、泛型的基本概念

 泛型的定义：泛型是JDK 1.5的一项新特性，它的本质是参数化类型（Parameterized Type）的应用，也就是说所操作的数据类型被指定为一个参数，在用到的时候在指定具体的类型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。

二、泛型的使用

泛型的参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。

1、泛型类的定义和使用

一个泛型类（generic class）就是具有一个或多个类型变量的类。定义一个泛型类十分简单，只需要在类名后面加上<>，再在里面加上类型参数：

1. class Pair<T> {  
2.     private T value;  
3.         public Pair(T value) {  
4.                 this.value=value;  
5.         }  
6.         public T getValue() {  
7.         return value;  
8.     }  
9.     public void setValue(T value) {  
10.         this.value = value;  
11.     }  
12. }  

1. public static void main(String[] args) throws ClassNotFoundException {  
2.         Pair<String> pair=new Pair<String>("Hello");  
3.         String str=pair.getValue();  
4.         System.out.println(str);  
5.         pair.setValue("World");  
6.         str=pair.getValue();  
7.         System.out.println(str);  
8.     }

类型变量使用大写形式，且比较短，这是很常见的。在Java库中，使用变量E表示集合的元素类型，K和V分别表示关键字与值的类型。（需要时还可以用临近的字母U和S）表示“任意类型”。

2.泛型接口的定义和使用

1. interface Show<T,U>{  
2.     void show(T t,U u);  
3. }  
4.   
5. class ShowTest implements Show<String,Date>{  
6.     @Override  
7.     public void show(String str,Date date) {  
8.         System.out.println(str);  
9.         System.out.println(date);  
10.     }  
11. } 

1. public static void main(String[] args) throws ClassNotFoundException {  
2.         ShowTest showTest=new ShowTest();  
3.         showTest.show("Hello",new Date());  
4.     }

3.泛型方法的定义和使用

1. public static void main(String[] args) throws ClassNotFoundException {  
2.         String str=get("Hello", "World");  
3.         System.out.println(str);  
4.     }  
5.   
6.     public static <T, U> T get(T t, U u) {  
7.         if (u != null)  
8.             return t;  
9.         else  
10.             return null;  
11.     }  

三、泛型变量的类型限制

有的时候，类、接口或方法需要对类型变量加以约束。看下面的例子：

有这样一个简单的泛型方法：

[java]  view plain  copy

1. public static <T> T get(T t1,T t2) {  
2.         if(t1.compareTo(t2)>=0);//编译错误  
3.         return t1;  
4.     }  

因为，在编译之前，也就是我们还在定义这个泛型方法的时候，我们并不知道这个泛型类型T，到底是什么类型，所以，只能默认T为原始类型Object。所以它只能调用来自于Object的那几个方法，而不能调用compareTo方法。

可我的本意就是要比较t1和t2，怎么办呢？这个时候，就要使用类型限定，对类型变量T设置限定（bound）来做到这一点。

我们知道，所有实现Comparable接口的方法，都会有compareTo方法。所以，可以对<T>做如下限定：

[java]  view plain  copy

1. public static <T extends Comparable> T get(T t1,T t2) { //添加类型限定  
2.         if(t1.compareTo(t2)>=0);  
3.         return t1;  
4.     }  

类型限定在泛型类、泛型接口和泛型方法中都可以使用，不过要注意下面几点：

1、不管该限定是类还是接口，统一都使用关键字 extends

2、可以使用&符号给出多个限定，比如

[java]  view plain  copy

1. public static <T extends Comparable&Serializable> T get(T t1,T t2)  

3、如果限定既有接口也有类，那么类必须只有一个，并且放在首位置

[java]  view plain  copy

1. public static <T extends Object&Comparable&Serializable> T get(T t1,T t2)