Java Sneppets

When you want to restrict the types that can be used as a type arguments in a parameterized type. Then you have to use bounded type parameters. Let us consider the following example. See how bounded type parameter is declared. Type parameter "U" followed by "extends" keyword, then followed by its upper bound (java.lang.Number)

BoundedTypeExample.java:

Output:

T: java.lang.Integer
U: java.lang.Integer

Consider the following code sneppet, since our invocation of inspect includes string, the compilation fails and results in error.

BoundedTypeExample integerClazz = new BoundedTypeExample();
integerClazz.setT(new Integer(10));
integerClazz.inspect(new Integer(20));
integerClazz.inspect("some string"); //ERROR::

ERROR:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
Bound mismatch: The generic method inspect(U) of type BoundedTypeIntro is not applicable for the arguments (String). The inferred type String is not a valid substitute for the bounded parameter

Summary:

Bounded type parameters allows you to do the following:

• Allows you to limit the types that you are using as a type arguments while instantiating a generic type.
• Also it allows you to invoke methods defined in the bounds.

The Java compiler erases type parameters in generic method arguments. Let us consider the following example to demonstrate two things:

• To demonstrate erasure of type parameters in generic method arguments
• To count number of occurrences of an element in an array

Its a technique used by the java compiler to do the following:

1) To replace/translate all parameterized type/ Generic type in Java Generics to raw types in bytecode.
2) To preserve type safety by inserting type casts if necessary.
3) To preserve polymorphism in extended generic types by generating bridge methods.

In JavaSE 7 or later you can replace the type arguments eg., 'String, Integer' with empty set of type arguments "<>". As long as compiler can determine or can do type inference, the type arguments.

This pair of  angle brackets "<>" is called as diamond operator.

For example you can create an instance of IGenericEntry with the following statement:

IGenericEntry entry1 = new GenericEntryImpl<>("Nithi", 30);

instead of

IGenericEntry entry1 = new GenericEntryImpl("Nithi", 30);

A generic class can have multiple type parameters. For example, the generic GenericEntryImpl, which implements the generic IGenericEntry interface:

IGenericEntry.java:


GenericEntryImpl.java:


GenericEntryTest.java:


Note:

• Due to autoboxing it is valid to pass a String and an int to the class.
• Java Compiler will take care of automatic conversion from an int to Integer.

Output:
Entry 1 -> Key:Nithi, Value:30
Entry 2 -> Key:Hello, Value:World

The Java Generics features were added to the Java language from Java 5. Generics add stability to your code so that you can detect most of the bugs during compile time.

Benefits of generics over non-generic code:

1) Stronger type checks at compile time
Java compiler applies strong type checking to generic code creates error if the code violates type safety. So it is always easy to fix compile time errors than runtime errors. 
The following code sneppet without generics requires type casting

List list = new ArrayList();
list.add("hello");
String string = (String) list.get(0);

When we rewrite the above to use generics, we no need to type cast:

List list = new ArrayList();
list.add("hello");
String string = list.get(0);   // no cast

3) Enable programmers to implement generic algorithms that work on collections of different types, can be customized, and are type safe.

Generic Types:
A generic type is a generic class or interface that is parameterized over types.

A simple Non-generic Class:
The problem with the following non-generic class is, there is no way to verify how the class is used during compile time.

NonGenericClazz.java:


A Generic Version of NonGenericClazz class:
The following is the way/technique to create generic version of non generic class:

GenericClazz.java:

Type variable can be any non-primitive type: any class type, any interface type, any array type or even any other type variable. The same way/technique can be used to create generic interfaces.

The most commonly used type parameter names are:
E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value

Invoking and Instantiating Generic Type:
GenericClazzTest.java:

Output:
get Integer:10

Try: integerClazz.setT("a String"); will result in compilation error. This shows, if generic code violates type safety, it would result in error as shown below:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
The method setT(Integer) in the type GenericClazz is not applicable for the arguments (String)

Note:
Understand the terminologies used in Java Generics i) Type Parameter  ii) Type Argument

• T in GenericClazz is a "type parameter"
• Integer in GenericClazz is a "type argument"