Generics are a facility of
generic programming
Generic programming is a style of computer programming in which algorithms are written in terms of types ''to-be-specified-later'' that are then ''instantiated'' when needed for specific types provided as parameters. This approach, pioneered b ...
that were added to the
Java programming language
Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is a general-purpose programming language intended to let programmers ''write once, run anywh ...
in 2004 within version
J2SE 5.0. They were designed to extend Java's
type system
In computer programming, a type system is a logical system comprising a set of rules that assigns a property called a type to every "term" (a word, phrase, or other set of symbols). Usually the terms are various constructs of a computer progra ...
to allow "a type or method to operate on objects of various types while providing compile-time type safety". The aspect ''
compile-time type safety'' was not fully achieved, since it was shown in 2016 that it is not guaranteed in all cases.
The
Java collections framework
The Java collections framework is a set of classes and interfaces that implement commonly reusable collection data structures.
Although referred to as a framework, it works in a manner of a library. The collections framework provides both inte ...
supports generics to specify the type of objects stored in a collection instance.
In 1998,
Gilad Bracha
Gilad Bracha is a software engineer at F5 Networks, and formerly at Google, where he was on the Dart programming language team. He is creator of the Newspeak language, and co-author of the second and third editions of the Java Language Specificati ...
,
Martin Odersky
Martin Odersky (born 5 September 1958) is a German computer scientist and professor of programming methods at École Polytechnique Fédérale de Lausanne (EPFL) in Switzerland. He specializes in code analysis and programming languages. He designed ...
, David Stoutamire and
Philip Wadler
Philip Lee Wadler (born April 8, 1956) is an American computer scientist known for his contributions to programming language design and type theory. He is the chair of Theoretical Computer Science at the Laboratory for Foundations of Computer S ...
created Generic Java, an extension to the Java language to support generic types. Generic Java was incorporated in Java with the addition of
wildcards.
Hierarchy and classification
According to ''Java Language Specification'':
*A
type variable In type theory and programming languages, a type variable is a mathematical variable ranging over types. Even in programming languages that allow mutable variables, a type variable remains an abstraction, in the sense that it does not correspond t ...
is an unqualified identifier. Type variables are introduced by generic class declarations, generic interface declarations, generic method declarations, and by generic constructor declarations.
*A class is generic if it declares one or more type variables. These type variables are known as the
type parameters of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized types share the same class at runtime.
*An
interface
Interface or interfacing may refer to:
Academic journals
* ''Interface'' (journal), by the Electrochemical Society
* ''Interface, Journal of Applied Linguistics'', now merged with ''ITL International Journal of Applied Linguistics''
* '' Inte ...
is generic if it declares one or more type variables. These type variables are known as the type parameters of the interface. It defines one or more type variables that act as parameters. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All parameterized types share the same interface at runtime.
*A method is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class or interface.
*A constructor can be declared as generic, independently of whether the class that the constructor is declared in is itself generic. A constructor is generic if it declares one or more type variables. These type variables are known as the formal type parameters of the constructor. The form of the formal type parameter list is identical to a type parameter list of a generic class or interface.
Motivation
The following block of Java code illustrates a problem that exists when not using generics. First, it declares an
ArrayList
of type
Object
. Then, it adds a
String
to the
ArrayList
. Finally, it attempts to retrieve the added
String
and cast it to an
Integer
—an error in logic, as it is not generally possible to cast an arbitrary string to an integer.
List v = new ArrayList();
v.add("test"); // A String that cannot be cast to an Integer
Integer i = (Integer)v.get(0); // Run time error
Although the code is compiled without error, it throws a runtime exception (
java.lang.ClassCastException
) when executing the third line of code. This type of logic error can be detected during compile time by using generics and is the primary motivation for using them.
The above code fragment can be rewritten using generics as follows:
List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // (type error) compilation-time error
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.
The logical flaw in the third line of this fragment will be detected as a
compile-time
In computer science, compile time (or compile-time) describes the time window during which a computer program is compiled.
The term is used as an adjective to describe concepts related to the context of program compilation, as opposed to concept ...
error (with J2SE 5.0 or later) because the compiler will detect that
v.get(0)
returns
String
instead of
Integer
. For a more elaborate example, see reference.
Here is a small excerpt from the definition of the interfaces
List
and
Iterator
in package :
public interface List
public interface Iterator
Type wildcards
A type argument for a parameterized type is not limited to a concrete class or interface. Java allows the use of ''type wildcards'' to serve as type arguments for parameterized types. Wildcards are type arguments in the form "
>
"; optionally with an upper or lower
bound
Bound or bounds may refer to:
Mathematics
* Bound variable
* Upper and lower bounds, observed limits of mathematical functions
Physics
* Bound state, a particle that has a tendency to remain localized in one or more regions of space
Geography
*B ...
. Given that the exact type represented by a wildcard is unknown, restrictions are placed on the type of methods that may be called on an object that uses parameterized types.
Here is an example where the element type of a
Collection
is parameterized by a wildcard:
Collection> c = new ArrayList();
c.add(new Object()); // compile-time error
c.add(null); // allowed
Since we don’t know what the element type of
c
stands for, we cannot add objects to it. The
add()
method takes arguments of type
E
, the element type of the
Collection
generic interface. When the actual type argument is
?
, it stands for some unknown type. Any method argument value we pass to the
add()
method would have to be a subtype of this unknown type. Since we don't know what type that is, we cannot pass anything in. The sole exception is
null
Null may refer to:
Science, technology, and mathematics Computing
*Null (SQL) (or NULL), a special marker and keyword in SQL indicating that something has no value
*Null character, the zero-valued ASCII character, also designated by , often used ...
; which is a member of every type.
To specify the
upper bound
In mathematics, particularly in order theory, an upper bound or majorant of a subset of some preordered set is an element of that is greater than or equal to every element of .
Dually, a lower bound or minorant of is defined to be an element ...
of a type wildcard, the
extends
keyword is used to indicate that the type argument is a subtype of the bounding class. So
List<? extends Number>
means that the given list contains objects of some unknown type which extends the
Number
class. For example, the list could be
List<Float>
or
List<Number>
. Reading an element from the list will return a
Number
. Adding null elements is, again, also allowed.
The use of wildcards above adds flexibility since there is not any inheritance relationship between any two parameterized types with concrete type as type argument. Neither
List
nor
List
is a subtype of the other; even though
Integer
is a subtype of
Number
. So, any method that takes
List
as a parameter does not accept an argument of
List
. 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
:
List ints = new ArrayList();
ints.add(2);
List nums = ints; // valid if List were a subtype of List according to substitution rule.
nums.add(3.14);
Integer x = ints.get(1); // now 3.14 is assigned to an Integer variable!
The solution with wildcards works because it disallows operations that would violate type safety:
List extends Number> nums = ints; // OK
nums.add(3.14); // compile-time error
nums.add(null); // allowed
To specify the lower bounding class of a type wildcard, the
super
keyword is used. This keyword indicates that the type argument is a supertype of the bounding class. So,
List<? super Number>
could represent
List<Number>
or
List<Object>
. Reading from a list defined as
List<? super Number>
returns elements of type
Object
. Adding to such a list requires either elements of type
Number
, any subtype of
Number
or
null
Null may refer to:
Science, technology, and mathematics Computing
*Null (SQL) (or NULL), a special marker and keyword in SQL indicating that something has no value
*Null character, the zero-valued ASCII character, also designated by , often used ...
(which is a member of every type).
The mnemonic PECS (Producer Extends, Consumer Super) from the book Effective Java by
Joshua Bloch
Joshua J. Bloch (born August 28, 1961) is an American software engineer and a technology author, formerly employed at Sun Microsystems and Google. He led the design and implementation of numerous Java platform features, including the Java Collec ...
gives an easy way to remember when to use wildcards (corresponding to
covariance
In probability theory and statistics, covariance is a measure of the joint variability of two random variables. If the greater values of one variable mainly correspond with the greater values of the other variable, and the same holds for the les ...
and
contravariance) in Java.
Generic class definitions
Here is an example of a generic Java class, which can be used to represent individual entries (key to value mappings) in a
map
A map is a symbolic depiction emphasizing relationships between elements of some space, such as objects, regions, or themes.
Many maps are static, fixed to paper or some other durable medium, while others are dynamic or interactive. Although ...
:
public class Entry
This generic class could be used in the following ways, for example:
Entry grade = new Entry("Mike", "A");
Entry mark = new Entry("Mike", 100);
System.out.println("grade: " + grade);
System.out.println("mark: " + mark);
Entry prime = new Entry(13, true);
if (prime.getValue()) System.out.println(prime.getKey() + " is prime.");
else System.out.println(prime.getKey() + " is not prime.");
It outputs:
grade: (Mike, A)
mark: (Mike, 100)
13 is prime.
Diamond operator
Thanks to
type inference
Type inference refers to the automatic detection of the type of an expression in a formal language. These include programming languages and mathematical type systems, but also natural languages in some branches of computer science and linguistics ...
, 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. Thus, the above code example using
Entry
can be rewritten as:
Entry grade = new Entry<>("Mike", "A");
Entry mark = new Entry<>("Mike", 100);
System.out.println("grade: " + grade);
System.out.println("mark: " + mark);
Entry prime = new Entry<>(13, true);
if (prime.getValue()) System.out.println(prime.getKey() + " is prime.");
else System.out.println(prime.getKey() + " is not prime.");
Generic method definitions
Here is an example of a generic method using the generic class above:
public static Entry twice(Type value)
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 many cases the user of the method need not indicate the type parameters, as they can be inferred:
Entry pair = Entry.twice("Hello");
The parameters can be explicitly added if needed:
Entry pair = Entry.twice("Hello");
The use of
primitive type
In computer science, primitive data types are a set of basic data types from which all other data types are constructed. Specifically it often refers to the limited set of data representations in use by a particular processor, which all compiled p ...
s is not allowed, and
boxed Boxed may refer to:
* Boxed.com, a wholesale on-line shopping site.
* ''Boxed'' (Eurythmics), an eight album box set
* ''Boxed'' (Mike Oldfield album)
* Boxed warning
In the United States, a boxed warning (sometimes "black box warning", colloq ...
versions must be used instead:
Entry pair; // Fails compilation. Use Integer instead.
There is also the possibility to create generic methods based on given parameters.
public Type[] toArray(Type... elements)
In such cases you can't use primitive types either, e.g.:
Integer[] array = toArray(1, 2, 3, 4, 5, 6);
Generics in throws clause
Although exceptions themselves cannot be generic, generic parameters can appear in a throws clause:
public void throwMeConditional(boolean conditional, T exception) throws T
Problems with type erasure
Generics are checked at compile-time for type-correctness. The generic type information is then removed in a process called
type erasure In programming languages, type erasure is the load-time process by which explicit type annotations are removed from a program, before it is executed at run-time. Operational semantics that do not require programs to be accompanied by types are ca ...
. For example,
List<Integer>
will be converted to the non-generic type
List
, which ordinarily contains arbitrary objects. The compile-time check guarantees that the resulting code is type-correct.
Because of type erasure, type parameters cannot be determined at run-time. For example, when an
ArrayList
is examined at runtime, there is no general way to determine whether, before type erasure, it was an
ArrayList<Integer>
or an
ArrayList<Float>
. Many people are dissatisfied with this restriction. There are partial approaches. For example, individual elements may be examined to determine the type they belong to; for example, if an
ArrayList
contains an
Integer
, that ArrayList may have been parameterized with
Integer
(however, it may have been parameterized with any parent of
Integer
, such as
Number
or
Object
).
Demonstrating this point, the following code outputs "Equal":
ArrayList li = new ArrayList();
ArrayList lf = new ArrayList();
if (li.getClass() lf.getClass())
Another effect of type erasure is that a generic class cannot extend the Throwable class in any way, directly or indirectly:
public class GenericException extends Exception
The reason why this is not supported is due to type erasure:
try
catch(GenericException e)
catch(GenericException e)
Due to type erasure, the runtime will not know which catch block to execute, so this is prohibited by the compiler.
Java generics differ from
C++ templates
C, or c, is the third letter in the Latin alphabet, used in the modern English alphabet, the alphabets of other western European languages and others worldwide. Its name in English is ''cee'' (pronounced ), plural ''cees''.
History
"C" ...
. Java generics generate only one compiled version of a generic class or function regardless of the number of parameterizing types used. Furthermore, the Java run-time environment does not need to know which parameterized type is used because the type information is validated at compile-time and is not included in the compiled code. Consequently, instantiating a Java class of a parameterized type is impossible because instantiation requires a call to a constructor, which is unavailable if the type is unknown.
For example, the following code cannot be compiled:
T instantiateElementType(List arg)
Because there is only one copy per generic class at runtime,
static variable
In computer programming, a static variable is a variable that has been allocated "statically", meaning that its lifetime (or "extent") is the entire run of the program. This is in contrast to shorter-lived automatic variables, whose storage is ...
s are shared among all the instances of the class, regardless of their type parameter. Consequently, the type parameter cannot be used in the declaration of static variables or in static methods.
Project on generics
Project Valhalla is an experimental project to incubate improved Java generics and language features, for future versions potentially from Java 10 onwards. Potential enhancements include:
*
generic specialization, e.g. List
* reified generics; making actual types available at runtime.
See also
* Generic programming
Generic programming is a style of computer programming in which algorithms are written in terms of types ''to-be-specified-later'' that are then ''instantiated'' when needed for specific types provided as parameters. This approach, pioneered b ...
* Template metaprogramming
Template metaprogramming (TMP) is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these te ...
* Wildcard (Java)
In the Java programming language, the wildcard ? is a special kind of type argument that controls the type safety of the use of generic (parameterized) types. It can be used in variable declarations and instantiations as well as in method definitio ...
* Comparison of C# and Java
* Comparison of Java and C++
References
{{DEFAULTSORT:Generics In Java
Java (programming language)
Polymorphism (computer science)