Generics in Java- How Generics Improve Type Safety

Assume we want to create a class that will work with various kinds of data. This can be done using generics and also by references of type object. Because Object is the superclass of all other classes, an Object reference can refer to any type object. Thus, in pre-generics code, generalized classes, interfaces, and methods used Object references to operate on various types of objects. First let us learn how to create such a class (class that will work with various kinds of data) Using Object references and problems found in this case.

Value 88 and "Generics Test” are Constructor arguments. Generic Classes don't infer types from constructor arguments.

Syntax:

Java 1.6 Syntax: Gen<Integer> iOb = new Gen<Integer>(88);

Java 1.7 Syntax: Gen<Integer> iOb = new Gen(88);

• Generics is introduced in JDK1.5 

• Classes, Class methods and Interfaces can be generic. 

• Generics work only with objects, not with primitive type. If primitive type is used then it will be converted to wrapper  classes (wrapper classes will be studied later) 

Gen<int> iOb = new Gen<int>(53); // Error, can't use primitive type

Value 53 is auto boxed and object appearance is obtained.

Gen<int> iOb = new Gen<Integer>(new Integer(88)); <==> Gen<int> iOb = new Gen<int>(53);

• Java professional rarely write generics, but extensively uses generics from libraries.   

• We can discard the generic support given by generic classes. Which we do for adding dissimilar data into some collection classes (those which allow dissimilar data).  

Type parameter Naming Convention

Usually type parameter names are single, uppercase letters to make it easily distinguishable from java variables. The most commonly used type parameter names are:

• E – Element (used extensively by the Java Collections Framework, for example ArrayList, Set etc.) 

• K – Key (Used in Map) 

• N – Number 

• T – Type 

• V – Value (Used in Map) 

• S,U,V etc. – 2nd, 3rd, 4th types 

A Generic Class with Two Type Parameters

Ouput:

The General Form of a Generic Class

As above program we can have more than one type parameter. The generics syntax shown in the preceding examples can be generalized. Here is the syntax for declaring a generic class:

class className<type-param-list> { // ...

Here is the syntax for declaring a reference to a generic class:

className<type-arg-list> var-name = new className<type-arg-list>(cons-arg-list);

The catch mechanism only works with non-generic types.

Bounded Types

• Type arguments can be direct/indirect subclasses of Upper Bound. 

• To set Upper Bound Syntax is  

<Type Parameter extends superclass>

• Bound can be  

• • Class (only one class at a time) 

  • Interface, can be one or more. 

  • Combination of class and interface.(Only one class at a time) 

When a bound includes an interface type, only type arguments that implement that interface are legal. When specifying a bound that has a class and an interface, or multiple interfaces, use the  & operator to connect them. For example:

    class Gen<T extends MyClass & MyInterface> { // ...

Here, T is bounded by a class called MyClass and an interface called MyInterface. Thus, any type argument passed to T must be a subclass of MyClass and implement MyInterface.

Advantage of using Bounded Types

Calculate sum of elements of a numeric array. Array can be of any numeric data type like byte, short, int, long, float, double. Calculate the sum of double version of elements.

In Stats, the average( ) method attempts to obtain the double version of each number in the nums array by calling doubleValue( ). Because all numeric classes, such as Integer and Double, are subclasses of Number, and Number defines the doubleValue( ) method, this method is available to all numeric wrapper classes. The trouble is that the compiler has no way to know that you are intending to create Stats objects using only numeric types. Thus, when we try to compile Stats, an error is reported that indicates that the doubleValue( ) method is unknown. To solve this problem, we need some way to tell the compiler that we intend to pass only numeric types to T. Furthermore, we need some way to ensure that only numeric types are actually passed. To handle such situations, Java provides bounded types.

What if Generic classes are used as parameters in methods?

Considering the following code, below table is an example for when Generic classes are used as parameters in methods.

Generic Method

Like generic class, we can create generic method that can accept any type of argument.

Let’s see a simple example of java generic method to print array elements. We are using here E to denote the element.

Output:

Erasure

An important constraint that governed the way that generics were added to Java was the need for compatibility with previous versions of Java. Simply put, generic code had to be compatible with preexisting, non-generic code. Thus, any changes to the syntax of the Java language, or to the JVM, had to avoid breaking older code. The way Java implements generics while satisfying this constraint is through the use of erasure.

In general, here is how erasure works. When your Java code is compiled, all generic type information is removed (erased). This means replacing type parameters with their bound type, which is Object if no explicit bound is specified, and then applying the appropriate casts (as determined by the type arguments) to maintain type compatibility with the types specified by the type arguments. The compiler also enforces this type compatibility. This approach to generics means that no type parameters exist at run time. They are simply a source-code mechanism.

This mechanism of erasing all details about generic after compilation is known as type erasing.