Generics in Java

[1] The aspect compile-time type safety required that parametrically polymorphic functions are not implemented in the Java virtual machine, since type safety is impossible in this case.

In 1998, Gilad Bracha, Martin Odersky, David Stoutamire and Philip Wadler created Generic Java, an extension to the Java language to support generic types.

This type of logic error can be detected during compile time by using generics[7] and is the primary motivation for using them.

The above code fragment can be rewritten using generics as follows: The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant of the ArrayList's generic Object constituents).

With generics, it is no longer necessary to cast the third line to any particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.

[9] Here is a small excerpt from the definition of the interfaces java.util.List and java.util.Iterator in package java.util: Here is an example of a generic Java class, which can be used to represent individual entries (key to value mappings) in a map: This generic class could be used in the following ways, for example: It outputs: Here is an example of a generic method using the generic class above: Note: If we remove the first in the above method, we will get compilation error (cannot find symbol "Type"), since it represents the declaration of the symbol.

In such cases you can't use primitive types either, e.g.: Thanks to type inference, Java SE 7 and above allow the programmer to substitute an empty pair of angle brackets (<>, called the diamond operator) for a pair of angle brackets containing the one or more type parameters that a sufficiently close context implies.

Wildcards are type arguments in the form ""; optionally with an upper or lower bound.

If it did, it would be possible to insert a Number that is not an Integer into it; which violates type safety.

Here is an example that demonstrates how type safety would be violated if List were a subtype of List: The solution with wildcards works because it disallows operations that would violate type safety: To specify the lower bounding class of a type wildcard, the super keyword is used.

The mnemonic PECS (Producer Extends, Consumer Super) from the book Effective Java by Joshua Bloch gives an easy way to remember when to use wildcards (corresponding to covariance and contravariance) in Java.

The compile-time check guarantees that the resulting code uses the correct type.

Demonstrating this point, the following code outputs "Equal": Another effect of type erasure is that a generic class cannot extend the Throwable class in any way, directly or indirectly:[15] The reason why this is not supported is due to type erasure: Due to type erasure, the runtime will not know which catch block to execute, so this is prohibited by the compiler.

[6] This is a benefit of using generic when compared to non-generic objects such as arrays.

However, if the developer attempts to add a String to this Long[] object, the program will throw an ArrayStoreException.

[6] This run-time exception can be completely avoided if the developer uses generics.

[6] Project Valhalla is an experimental project to incubate improved Java generics and language features, for future versions potentially from Java 10 onwards.