A generic class, interface or method in Java is parameterized by one or more types. Generics in Java allow one implementation of a collection or algorithm to be reused with different reference types while checking the allowed values and results statically. For example:The type parameter is declared inside angle brackets, as in
Vector<String> names = new Vector<String>();
names.add("Ada");
String first = names.get(0);
class Box<T> {
private T value;
public void put(T x) { value = x; }
public T get() { return value; }
}Box<T>, and supplied as a type argument, as in Box<String>. A generic method places its parameter list before its return type, for example static <T> T identity(T x). Bounds such as <T extends Number> restrict type arguments, and wildcards such as ? extends Number or ? super Integer describe restricted views. Primitive values require wrapper types such as Integer rather than a type argument int. Generics provide reusable code with compile-time checking of element types.Replace type parameters by their erasures, normally The two fragments are alternatives, not consecutive declarations in one scope. For a user-defined
Object or the first declared bound, and insert checked casts where an erased result is used as its former specific type. A simple generics in Java example becomes:// Generic version
Vector<String> names = new Vector<String>();
names.add("Ada");
String s = names.get(0);
// Non-generic version
Vector names = new Vector();
names.add("Ada");
String s = (String) names.get(0);Box<T>, replace fields, parameters and returns of type T by Object, and cast the retrieved result. Bounded parameters instead erase to their bound. A full translation must also preserve method dispatch where erasure changes overridden signatures, using suitable forwarding methods; this is the principle of type erasure, not simply deleting every pair of angle brackets.The raw collection permits accidental insertion of an unrelated object, which may fail much later at a cast. The generic collection rejects such insertion during compilation, documents its contract at the declaration, and eliminates repetitive casts at use sites. The generic version catches more errors earlier and expresses the programmer's intended element type directly. Generic types are largely erased at runtime, so their advantage is static checking rather than a new runtime vector representation. The translation mechanism is specified by the Java language specification.
The inference is false in both directions. Although
String is a subtype of Object, generic type invariance means that neither Vector<String> nor Vector<Object> is a subtype of the other. If a string vector could be used as an object vector, an arbitrary object could be inserted into storage promised to contain strings. Conversely, an object vector may already contain an Integer, so it cannot satisfy the contract of a string vector.Both parameterizations are subtypes of the ordinary class
Object, but this does not create a subtype relation between their element parameterizations. For a view accepting vectors with different element types, Vector<?> is appropriate; a Vector<? extends Object> similarly allows retrieval as Object without arbitrary non-null insertion. A Vector<? super String> accepts insertion of strings but does not promise that retrieved elements are strings. The stated subclass relationship does not hold: mutable generic vectors are invariant. Articles by others on the same topic
There are currently no matching articles.