Java: Generics 泛型

Generics allow you to abstract over types

这里的 types 指的是什么？The Java programming language includes classes and interfaces, both are collectively re-ferred to as types. (见附件 Choosing Efficient Inheritance Patterns for Java Generics)

好文一篇 - Java Generics FAQs：
http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html
Java Tutorials - Generics(Updated):
http://docs.oracle.com/javase/tutorial/java/generics/index.html
Java Tutorials - Generics(老的，看看即可):
http://docs.oracle.com/javase/tutorial/extra/generics/intro.html
http://www.oracle.com/technetwork/articles/javase/generics-136597.html
Java 1.5 Generics Tutorial: How Generics in Java works with Example of Collections, Best practices, Gotchas：
http://javarevisited.blogspot.com/2011/09/generics-java-example-tutorial.html

几个概念:

generic type

引用

A generic type is a generic class or interface that is parameterized over types.

type parameter(also called type variable)

引用

A place holder for a type argument.
Generic types have one or more type parameters.
Each type parameter is replaced by a type argument when an instantiation of the generic type.

By convention, type parameter names are single, uppercase letters. This stands in sharp contrast to the variable naming conventions that you already know about, and with good reason: Without this convention, it would be difficult to tell the difference between a type variable and an ordinary class or interface name.
The most commonly used type parameter names are:
E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types

type argument

引用

A reference type or a wildcard that is used for instantiation of a generic type or a reference type used for instantiation of a generic method.  An actual type argument replaces the formal(形式化的) type parameter used in the declaration of the generic type or method.

parameterized type

引用

The instantiation(or invocation) of a generic type with actual type arguments is called a parameterized type

type inference

引用

Type inference is a Java compiler's ability to look at each method invocation and corresponding declaration to determine the type argument (or arguments) that make the invocation applicable. The inference algorithm determines the types of the arguments and, if available, the type that the result is being assigned, or returned. Finally, the inference algorithm tries to find the most specific type that works with all of the arguments.

例子

        /**
         * List & ArrayList 都是 generic type(细说的话，前者是 generic interface, 后者是 generic class)
         * List & Array 类定义上的 <E> 中的 E 为 type parameter(also called type variable)
         * Integer 为 type argument
         * List<Integer> 为 parameterized type
         *
         */
        List<Integer> list = new ArrayList<Integer>();

Generic Methods

Not only types can be generic, but methods can be generic, too. Static and non-static methods as well as constructors can have type parameters. The syntax for declaration of the formal type parameters is similar to the syntax for generic types. The type parameter section is delimited by angle brackets and appears before the method's return type. Its syntax and meaning is identical to the type parameter list of a generic type.

Wildcards(通配符)

http://docs.oracle.com/javase/tutorial/java/generics/subtyping.html
In generic code, the question mark (?), called the wildcard, represents an unknown type, or a family of types. 
There are 3 different flavors of wildcards:
" ? " - the unbounded wildcard. It stands for the family of all types.
" ? extends Type " - a wildcard with an upper bound. It stands for the family of all types that are subtypes of Type , type Type being included.
" ? super Type " - a wildcard with a lower bound. It stands for the family of all types that are supertypes of Type , type Type being included.

PECS (short for Producer extends and Consumer super)

http://stackoverflow.com/questions/2723397/java-generics-what-is-pecs

引用

要站在collection的角度理解 producer & consumer：
当需要 get(从 collection 中取) 时，collection 扮演的是 producer 的角色，所以使用 extends;
当需要 put(往 collection 中放) 时，collection 扮演的是 consumer 的角色，所以使用super。

Bounded Type Parameter 和 upper bounded wildcard 的区别是什么？
http://stackoverflow.com/questions/1750273/what-is-the-difference-between-bounded-wildcard-and-type-parameters?rq=1
http://stackoverflow.com/questions/3486689/java-bounded-wildcards-or-bounded-type-parameter


泛型与继承：
http://www.ibm.com/developerworks/cn/java/j-lo-gj/

引用

在 Java 语言中，我们可以将某种类型的变量赋值给其父类型所对应的变量，例如，String 是 Object 的子类型，因此，我们可以将 String 类型的变量赋值给 Object 类型的变量，甚至可以将 String [ ] 类型的变量（数组）赋值给 Object [ ] 类型的变量，即 String [ ] 是 Object [ ] 的子类型。
上述情形恐怕已经深深地印在了广大读者的脑中，对于泛型来讲，上述情形有所变化，因此请广大读者务必引起注意。为了说明这种不同，我们还是先来分析一个小例子，代码如下所示：

List<String> ls = new ArrayList<String>(); 
	List<Object> lo = ls; 
	lo.add(new Integer()); 
	String s = ls.get(0); 

上述代码的第二行将 List<String>赋值给了 List<Object>，按照以往的经验，这种赋值好像是正确的，因为 List<String>应该是 List<Object>的子类型。这里需要特别注意的是，这种赋值在泛型当中是不允许的！ List<String>也不是 List<Object>的子类型。
如果上述赋值是合理的，那么上面代码的第三行的操作将是可行的，因为 lo是 List<Object>，所以向其添加 Integer 类型的元素应该是完全合法的。读到此处，我们已经看到了第二行的这种赋值所潜在的危险，它破坏了泛型所带来的类型安全性。
一般情况下，如果 A 是 B 的子类型，C 是某个泛型的声明，那么 C<A>并不是 C<B>的子类型，我们也不能将 C<A>类型的变量赋值给 C<B>类型的变量。这一点和我们以前接触的父子类型关系有很大的出入，因此请读者务必引起注意。