In a broad definition, generic programming is a style of computer programming in which algorithms are written in terms of to-be-specified-later types that are then instantiated when needed for specific types provided as parameters...
Java is a programming language originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities...
Java Platform, Standard Edition or Java SE is a widely used platform for programming in the Java language. It is the Java Platform used to deploy portable applications for general use...
5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." A common use of this feature is when using a Java Collection that can hold objects of any type, to specify the specific type of object stored in it.
Hierarchy and classification
As per Java Language Specification:
A type variable 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 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 of 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 for generics
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.
List v = new ArrayList;
v.add("test");
Integer i = (Integer)v.get(0); // Run time error
Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation for using generics.
Using generics, the above code fragment can be rewritten as follows:
List v = new ArrayList;
v.add("test");
Integer i = v.get(0); // (type error) Compile 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.
Compiling the third line of this fragment with J2SE 5.0 (or later) will yield a compile-time error 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 definitions of the interfaces List and Iterator in package :
public interface List {
void add(E x);
Iterator iterator;
}
public interface Iterator {
E next;
boolean hasNext;
}
Wildcards
Generic type parameters in Java are not limited to specific classes. Java allows the use of wildcards to specify bounds on the type of parameters a given generic object may have. Wildcards are type parameters of the form "?", possibly annotated with a bound. Given that the exact element type of an object with a wildcard is unknown, restrictions are placed on the type of methods that may be called on the object.
As an example of an unbounded wildcard, List<?> indicates a list which has an unknown object type. Methods
Method (computer science)
In object-oriented programming, a method is a subroutine associated with a class. Methods define the behavior to be exhibited by instances of the associated class at program run time...
which take such a list as an argument can take any type of list, regardless of parameter type. Reading from the list will return objects of type Object, and writing non-null elements to the list is not allowed, since the parameter type is not known.
In type theory, bounded quantification refers to universal or existential quantifiers which are restricted to range only over the subtypes of a particular type. Bounded quantification is an interaction of parametric polymorphism with subtyping...
of a generic element, the extends keyword is used, which indicates that the generic type is a subtype of the bounding class. Thus it must either extend the class, or implement the interface 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, while writing non-null elements is once again not allowed.
The use of wildcards above is necessary since objects of one type parameter cannot be converted to objects of another parameter. Neither List nor List is a subtype of the other, even though Integer is a subtype of Number. So, code that deals with List does not work with 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 sample code that explains the contradiction it brings 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.
To specify the lower bounding class of a generic element, the super keyword is used. This keyword indicates that the aforementioned generic type is a super-type of said 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. Writing to such a list requires elements of type Number.
This generic class can be used in the following way:
Entry grade440 = new Entry("mike", "A");
Entry marks440 = new Entry("mike", 100);
System.out.println("grade: " + grade440);
System.out.println("marks: " + marks440);
Generic method definitions
Here is an example of a generic method using the generic class above:
public static Entry twice(T value) {
return new SimpleImmutableEntry(value, value);
}
In many cases the user of the method need not indicate the type parameters, as they can be inferred:
Entry pair = twice("Hello");
The parameters can be explicitly added if needed:
Entry pair = this.twice("Hello");
Note that you cannot use native types, ex:
Entry pair; // this fails. You have to use Integer instead.
There is also the possibility to create generic methods based on given parameters.
public T[] toArray(T... elements) {
return elements;
}
In such cases you can't use native types either, ex:
Integer[] array = toArray(1,2,3,4,5);
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 {
if(conditional)
throw exception;
}
Type erasure
Generics are checked at compile-time for type-correctness. The generic type information is then removed in a process called type erasure. For example, List<Integer> will be converted to the non-generic type List, which can contain arbitrary objects. The compile-time check guarantees that the resulting code is type-correct.
As a result 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 was presumably parameterized with Integer. Reflection
Reflection (computer science)
In computer science, reflection is the process by which a computer program can observe and modify its own structure and behavior at runtime....
can also determine the type parameter. However, no approach works in all cases.
Demonstrating this point, the following code outputs "Equal":
ArrayList li = new ArrayList;
ArrayList lf = new ArrayList;
if (li.getClass lf.getClass) // evaluates to true
System.out.println("Equal");
Java generics differ from C++ templates. 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 will not compile:
T instantiateElementType(List arg) {
return new T; //causes a compile error
}
Because there is only one copy per generic class at runtime, static variables are shared among all the instances of the class, regardless of their type parameter. As a result, the type parameter cannot be used in the declaration of static variables or in static methods. Static variables and static methods are "outside" of the scope of the class's parameterized types.
See also
In a broad definition, generic programming is a style of computer programming in which algorithms are written in terms of to-be-specified-later types that are then instantiated when needed for specific types provided as parameters...
The wildcard ? in Java is a special actual parameter for the instantiation of generic types. It can be used for the instantiation, not in the definition of a generic unit...
Java is a programming language originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities...
This article compares Microsoft's C# programming language with Oracle's Java programming language. While the focus of this article is mainly the programming languages and their features, such a comparison will necessarily also consider some platform features and some library features...
This is a comparison of the Java programming language with the C++ programming language.- Design aims :The differences between the C++ and Java programming languages can be traced to their heritage, as they have different design goals....
JavaWorld is an online technology website focused on Java technologies, founded in 1996. Since 2006, JavaWorld has become a subsidiary of Network World...
