java泛型--问号？和T或E或K或V的区别

所谓泛型，就是在定义类、接口、方法、参数或成员变量的时候，指定它们操作对象的类型为通用类型。

使用 尖括号 <> 操作符 (The diamond operator )表示泛型, 尖括号内可以放置大写字母 （代表一个未知类型） 或问号 ? （代表若干个类型）作为参数。比如，习惯上选择以下字母代表某种类型：

1. T 意味某种类型
2. E 意味 链表、数组里的元素，如List<E> list 表示 list 里的元素。
3. K意味map(k,v) 里的键值 Key
4. V 意味 返回或映射的值。

然而，泛型的运用要受到如下限制 ：

1. 不能使用基本类型的类型参数，可以使用其包装类型代替。
2. 静态成员无法使用类型参数。
3. 不能使用泛型类异常
4. 不能实例化泛型对象或数组，如：

T t = new T();  T[] a=new T;

5,. 不能使用泛型数组，如：

import java.util.*;
public class Test{
public static void main(String args[]){
	List<String> arr[] = new ArrayList<String>[5];
	}
}

D:\java\test\OS_China\generic>javac Test.java
Test.java:5: 错误: 创建泛型数组
        List<String> arr[] = new ArrayList<String>[5];
                             ^
1 个错误

至于代表若干类的，放在尖括号内的通配符 ？：<?>，还分 上限通配符 (Upper Bounded Wildcards) 和 下限通配符 (Lower Bounded Wildcards)。

论点：

上限通配符 <?  extends  U> 可以代表这个未知类型 U，或者 通过关键字 extends 所能想象出的 U 类的任何一个子类。同样，下限通配符 <?  super  L> 可以代表这个未知类型 L，或者 通过关键字 super 所能想象出的 L类的任何一个超类。

这里分别以多个接口 interface 和 多个类 class 为基础， 创建 继承关系。

并以通过编译的代码, 证明以上论点成立。

/* <? super T> 与 <? extends T> 的区别，
 *  T 代表一个给定的接口
 * */
import java.util.*;
interface A1{}
interface A2{}
interface A3{}
interface A4{}

interface B1 extends A1{}
interface B2 extends A1,A2{}
interface B3 extends A3,A4{}
interface B4 extends A4{}

interface C1 extends B2{}
interface C2 extends B2,B3{}
interface C3 extends B3{}

interface D1 extends C1,C2{}
interface D2 extends C2{}

interface E1 extends D1{}
interface E2 extends D1{}
interface E3 extends D2{}
interface E4 extends D2{}

public class UP_Interface {	

public static void main(String args[]){
/********************************************
 * 此处 extends 表示 有上界的统配符 ?，上界为  C2
 * 由此定义的引用 listUpper可以作为
 * 接下来的 7 种 子泛型类型的 ArrayList 的引用来使用。
 **********************************************/
   List<? extends C2> listUpper;//上界统配符 ?， 上界为  C2
listUpper=new ArrayList<C2>();//能存储 C2 D1 D2 E1 E2 E3 E4
listUpper=new ArrayList<D1>();//能存储    D1    E1 E2
listUpper=new ArrayList<D2>();//能存储       D2       E3 E4
listUpper=new ArrayList<E1>();//能存储          E1
listUpper=new ArrayList<E2>();//能存储             E2
listUpper=new ArrayList<E3>();//能存储                E3
listUpper=new ArrayList<E4>();//能存储				   E4

/*************************************************
 * super 表示有下界的统配符 ? ，下界为  C2 ，
 * 由此定义的引用 listLower 可以作为
 * 接下来的 7 种 子泛型类型的 ArrayList 的引用来使用。
 ***************************************************/
List<? super C2> listLower;
listLower=new ArrayList<A1>(); //能存储 A1          B1 B2       C1 C2    D1 D2 E1 E2 E3 E4
listLower=new ArrayList<A2>(); //能存储    A2          B2       C1 C2    D1 D2 E1 E2 E3 E4
listLower=new ArrayList<A3>(); //能存储       A3          B3       C2 C3 D1 D2 E1 E2 E3 E4
listLower=new ArrayList<A4>(); //能存储          A4       B3 B4    C2 C3 D1 D2 E1 E2 E3 E4
listLower=new ArrayList<B2>(); //能存储                B2       C1 C2    D1 D2 E1 E2 E3 E4
listLower=new ArrayList<B3>(); //能存储                   B3       C2 C3 D1 D2 E1 E2 E3 E4
listLower=new ArrayList<C2>();// 能存储                            C2    D1 D2 E1 E2 E3 E4
	}
}

/* <? super T> 与 <? extends T> 的区别，
 *  T 代表一个给定的类
 * */
import java.util.*;

class A1{}
class A2{}
class A3{}
class A4{}

class B1 extends A1{}
class B2 extends A1{}
class B3 extends A3{}
class B4 extends A4{}

class C1 extends B2{}
class C2 extends B2{}
class C3 extends B3{}

class D1 extends C1{}
class D2 extends C2{}

class E1 extends D1{}
class E2 extends D1{}
class E3 extends D2{}
class E4 extends D2{}

public class UP_Class{	

public static void main(String args[]){
/********************************************
 * 此处 extends 表示 有上界的统配符 ?，上界为  C2
 * 由此定义的引用 listUpper可以作为
 * 接下来的 7 种 子泛型类型的 ArrayList 的引用来使用。
 **********************************************/
   List<? extends C2> listUpper;//统配符 ? 的上界为  C2
listUpper=new ArrayList<C2>();//能存储 C2 D2 E3 E4
listUpper=new ArrayList<D2>();//能存储 D2 E3 E4
listUpper=new ArrayList<E3>();
listUpper=new ArrayList<E4>();
/*************************************************
 * super 表示有下界的统配符 ? ，下界为  C2 ，
 * 由此定义的引用 listLower 可以作为
 * 接下来的 7 种 子泛型类型的 ArrayList 的引用来使用。
 ***************************************************/
List<? super C2> listLower;
listLower=new ArrayList<A1>(); //能存储 A1 B1 B2 C1 C2    D1 D2 E1 E2 E3 E4
listLower=new ArrayList<B2>(); //能存储 B2       C1 C2    D1 D2 E1 E2 E3 E4
listLower=new ArrayList<C2>();// 能存储 D2 E3 E4
	}
}