Generics

With the objective of decreasing bugs and adding an additional layer of abstraction over types, Java Generics was implemented in JDK 5.0.

This article is a fast introduction to Java's generics, the objective behind them and how they can be used to enhance our code quality.

Java generics are similar to C++ templates. The concept is to allow type (Integer, String, ... and types identified by the user) to be a parameter for methods, classes, and interfaces. For example, classes such as HashSet, ArrayList, HashMap, etc., use generics well. They can be used for any type.

Generics-using programs have many advantages over the non-generic code.

1. Code Reuse
   We can write a method/class/interface once and use it for whatever type we want.
2. Type Safety
   Generics create compile-time errors rather than run-time mistakes (it's always better to understand compile-time issues in your code than failing to run your code). Suppose you want to build an ArrayList that will store student names, and if the programmer adds an integer object instead of a string by error, the compiler will allow it. But when this information is retrieved from ArrayList, it creates runtime issues.

Syntax to create a generic type object:

Class_name <java data type> reference_name = new Class_name<data type> (); 
OR 
Class_name <java data type> reference_name = new Class_name<>(); 

This is also referred to as the Diamond Notation producing a generic type object.

Example of Generic class

class Gen <T> //<> brackets indicates that the class is of generic type 
{ 
T ob;     //an object of type T is declared 
Gen(T o)  //constructor 
{ 
  ob = o; 
} 
public T getOb() 
{ 
return ob; 
} 
} 
class Test 
{ 
public static void main (String[] args) 
{ 
  Gen <Integer> iob = new Gen<>(150);      
int  x = iob.getOb(); 
  System.out.println(x); 
  Gen < String> sob = new Gen<>("Hello John");   
  String str = sob.getOb(); 
  System.out.println(str); 
} 
} 

Output:

150 
Hello John 

We passed an Integer type parameter to the Generic class for the first time in the above program. Then we passed the same generic class with a String type parameter. Therefore, for two distinct data types, we reused the same class. Generics thus facilitate the reusability of code.

Generics Work Only with Objects

Generics only work with objects, i.e. the type argument must be a class type. You can't use primitive data types like int, char, etc. with generic type. It should be an object at all times. As a generic type, we can use all objects of the Wrapper Class and String class objects.

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

Generics Types of different Type Arguments are never same in Java

Unless their type reasoning is the same, the reference of one generic type is never consistent with another generic type. In the above example, we created two objects of the Gen class, one of the Integer type and another of the String type.

iob = sob;    //Absolutely Wrong 

An array of Generic type cannot be created in Java

It is not permitted to create a generic type array in generic programming. We can make an array reference, but we can't set it up.

For example, In the above program, in class Gen,

T a[]; //this is allowed 
T a[] = new T[10]; //this is not allowed 

Generic Type with more than one parameter

We can transfer more than 1 data type as a parameter in generic parameter types. It operates the same as with the generic type of one parameter.

class Gen <T1,T2> 
{ 
T1 name; 
T2 value; 
Gen(T1 o1,T2 o2) 
{ 
  name = o1; 
  value = o2; 
} 
public T1 getName() 
{ 
return name; 
} 
public T2 getValue() 
{ 
return value; 
} 
} 
class Test 
{ 
public static void main (String[] args) 
{ 
  Gen < String,Integer> obj = new Gen<>("MovieTonight",678); 
  String  s = obj.getName(); 
  System.out.println(s); 
  Integer i = obj.getValue(); 
  System.out.println(i); 
} 
}   

Output:

MovieTonight 
678 

Note: Therefore, as there are two parameters in Generic Class-T1 and T2, while generating an example of this Generic Class, we need to mention two types of information that need to be passed to this class as a parameter.

Generic Methods in Java

You can also generate generic methods with various types of arguments that can be called. The compiler handles each method based on the sort of arguments passed to the generic method.

The syntax for a generic method includes a type parameter, inside angle brackets, that should appear before the return type of the method.

<type-parameter> return_type method_name (parameters) {...} 

Example of Generic method

class GenTest 
{ 
static <b>< V, T></b> void display (V v, T t) 
 { 
  System.out.println(v.getClass().getName()+" = " +v); 
  System.out.println(t.getClass().getName()+" = " +t); 
 } 
public static void main(String[] args) 
 { 
display(88,"This is string"); 
 } 
} 

Output:

java lang.Integer = 88 
java lang.String = This is string 

Generic Constructors in Java

A generic constructor can be created even if the class is not generic.

Example of Generic Constructor

class Gen 
{ 
private double val; 
 < T extends Number> Gen(T ob) 
 { 
  val=ob.doubleValue(); 
 } 
void show() 
 { 
  System.out.println(val); 
 } 
} 
class Test 
{ 
public static void main(String[] args) 
 { 
  Gen g = new Gen(100); 
  Gen g1 = new Gen(121.5f); 
  g.show(); 
  g1.show(); 
 } 
} 

Output:

100.0 
121.5 

Generic Interface in Java

You can also generate generic interfaces like classes and methods.

interface MyInterface< T > 
{ .. } 

Generic Bounded type Parameter

You can also set the type restriction that can be passed to a type parameter. This is achieved when specifying the type parameter with the assistance of extends keyword.

 < T extends Number > 

We took Number class here, it can be any name of the wrapper class. This indicates that only Number class information or any of its subclasses can replace T.

Generic Method with bounded type Parameters

class Gen 
{ 
static < T, V extends number> void display(T t, V v) 
 { 
  System.out.println(v.getClass().getName()+" = " +v); 
  System.out.println(t.getClass().getName()+" = " +t); 
 } 
public static void main(String[] args) 
 { 
// display(98,"This is string"); 
  display ("this is string",99); 
 } 
} 

Output:

java.lang.String = This is string 
java.lang.Double = 99.O 

1. Type V is limited only to the type of number and its subclass.
2. If display(98,"This is string") is uncommented in above program, it will offer an incompatibility type error, since String is not a Number class subclass.