Generics in Java

Generics in Java
Parameterizedtypes mean generic. Generics allow types (Character, Integer,
String, …, etc., as well as user-defined types) to act as parameters to interfaces,
classes, and methods. Generics in Java facilitate the creation of classes that
deal with different types of datatypes. Entities, such as methods, interfaces,
classes that act on the parameterized type,are known as the generic entity.
Generics is similar to template C++ templates.
Need of Generics in Java
We know that theObject class is the parent class of all the Java classes, and
hence,it is obvious that the Object reference can refer to any object. These
features do not ensure type safety.To achieve the same in Java, we
use Generics.
Generics Class in Java
Similar to C++, we use angular brackets (<>) to mention parameter types in the
creation of the generic class.
Syntax:
// For creating an object of a generic class

GenericClass<T> obj = new GenericClass<T>();

Where T refers to parameter type such as String, Character,

Integer, etc.
Note: In the parameter,use of primitive type is not allowed. For example, 'char',
'int', 'float', 'double'
Generics Class Examples
FileName: GenericsExample.java
// A Java program that shows the working of the user-defined

// Generic class

// We use <> to specify Parameter type

class ABC<Type>

// Declaring an object of type "Type"

Type obj;

// constructor of the class ABC

ABC(Type obj)
{

this.obj = obj;

// returning the object

public Type getObject()

return this.obj;

public class GenericsExample

// main method

public static void main (String argvs[])

// An instance of the Integer type

ABC <Integer> intObj = new ABC<Integer>(17);

System.out.println("The value of the integer is: " +

intObj.getObject());

// An instance of the String type

ABC <String> strObj = new ABC<String>("Tutorial & Example");

System.out.println("The value of the string is: " +

strObj.getObject());

// An instance of the Float type

ABC <Float> floatObj = new ABC<Float>(9.9f);

System.out.println("The value of the float is: " +

floatObj.getObject());

// An instance of the Character type

ABC <Character> charObj = new ABC<Character>('E');

System.out.println("The value of the char is: " +

charObj.getObject());

}
Output:
The value of the integer is: 17

The value of the string is: Tutorial & Example

The value of the float is: 9.9

The value of the char is: E

Explanation:The above-written code showshow easy it is to create instances of
different datatypes with the help of the user-defined Generic class ABC.
Let’s see another example of Java generic.
FileName: GenericsExample1.java
// A Java program that shows the working of the user-defined

// Generic class having multiple parameters

// We use <> to specify Parameter type

class ABC<U, T>

// A reference of type U

U uObj;

// A reference of type T

T tObj;

// constructor of the class ABC

ABC(U obj1, T obj2)

this.uObj = obj1;

this.tObj = obj2;

}
// For printing the objects of types T and U

public void print()

System.out.println(uObj);

System.out.println(tObj);

// a method for returning object of type T

public T getTObj() { return tObj; }

// a method for returning object of type U

public U getUObj() { return uObj; }

// Driver class

public class GenericsExample1

// main method

public static void main (String argvs[])

// An instance of the Integer, Character type

ABC <Integer, Character> intCharObj = new ABC<Integer,

Character>(10, 'Q');

System.out.println("The value of the integer is: " +

intCharObj.getUObj());

System.out.println("The value of the character is: " +

intCharObj.getTObj());

// An instance of the String, Float type

ABC <String, Float> strFloatObj = new ABC<String,

Float>("Tutorial & Example", 78.90f);
System.out.println("The value of the string is: " +
strFloatObj.getUObj());

System.out.println("The value of the float is: " +

strFloatObj.getTObj());

// An instance of the Character, Float type

ABC <Character, Float> charFloatObj = new ABC<Character,

Float>('V', 7.09f);

System.out.println("The value of the character is: " +

charFloatObj.getUObj());

System.out.println("The value of the float is: " +

charFloatObj.getTObj());

}
Output:
The value of the integer is: 10

The value of the character is: Q

The value of the string is: Tutorial & Example

The value of the float is: 78.9

The value of the character is: V

The value of the float is: 7.09

Generics Methods in Java

Similar to Generic Classes,Java allows us to create generics methods. Observe
the following program.
FileName: GenericsExample2.java
// A Simple Java program to show working of user defined

// Generic functions

public class GenericExample2

// A Generic method example

public <T> void display (T ele)

{

System.out.println(ele.getClass().getName() + " = " + ele);

// main mehtod

public static void main(String argvs[])

// creating an instance of the class GenericExample2

GenericExample2 obj = new GenericExample2();

// invoking the generic method with the Integer argument

obj.display(151);

// Calling generic method with String argument

obj.display("Tutorial & Example");

// Calling generic method with float argument

obj.display(1.51f);

// Calling generic method with double argument

obj.display(1.67);

}
Output:
java.lang.Integer = 151

java.lang.String = Tutorial & Example

java.lang.Float = 1.51

java.lang.Double = 1.67

Advantages of Generics in Java

1) Generics ensure type safety:Generics ensure type safety through various
ways. Observe the following code.
FileName: GenericsExample3.java
// A basic Java program to demonstrates
// the working of the user-defined

// Generic class

// We use <> to specify Parameter type

class ABC<P>

// An object of type P is declared

P obj;

ABC(P obj) { this.obj = obj; } // constructor

public P getObject() { return this.obj; }

// Driver class for doing

// the testing of above

public class GenericsExample3

// main method

public static void main (String argvs[])

// an instance of the Integer type

ABC <Integer> intObj = new ABC<Integer>(105);

System.out.println("The value of the integer is" +

intObj.getObject());

// an instance of the String type

ABC <String> strObj = new ABC<String>("Tutorial &

Example");

System.out.println("The value of the string is " +

strObj.getObject());

intObj = strObj; // it results in an error

}

}
Output:

Explanation:Even thoughintObj and strObj are the objects of the same class
ABC, they represent the difference in parameter type. Hence, the error occurs,
which shows that Generics ensures type safety.
Not only this, but Generics also helps to make errors appear at the compile time.
Supposethere is an ArrayList (without Generic) that stores the person’s name,
and if someone stores a number by mistake, this mistakeignored by the compiler.
Observe the following code.
FileName: GenericsExample4.java
// A Simple Java program to demonstrate that NOT using

// generics may cause run time exceptions

// importing ArrayList

import java.util.ArrayList;

public class GenericsExample4

// main method

public static void main(String argvs[])

// Creating an ArrayList that has not specified any type

ArrayList personNames = new ArrayList();

personNames.add("Rahul Dravid");

personNames.add("Virender Sehwag");

personNames.add("Sachin Tendulkar");

personNames.add("Zaheer Khan");

personNames.add("Virat Kohli");

personNames.add("Anil Kumble");
 personNames.add(12); // Compiler accepts it without any
issue

// size of the array list

int size = personNames.size();

// printing the ArrayList elements

for(int i = 0; i < size; i++)

System.out.println(personNames.get(i));

}
Output:
Rahul Dravid

Virender Sehwag

Sachin Tendulkar

Zaheer Khan

Virat Kohli

Anil Kumble

12
Explanation:Till this point, everything seems fine.However, it should not be fine,
as 12 should not be entertained in the person’s name list. The above code is
potent to throw an exception or error. Supposethe next task is to find the length
of strings present in the list, then at that time, we will face issues. Observe the
following code.
FileName: GenericsExample5.java
// A Simple Java program to demonstrate that NOT using

// generics may cause run time exceptions

// importing ArrayList

import java.util.ArrayList;
public class GenericsExample5

// main method

public static void main(String argvs[])

// Creating an ArrayList that has no any type specified

ArrayList personNames = new ArrayList();

personNames.add("Rahul Dravid");

personNames.add("Virender Sehwag");

personNames.add("Sachin Tendulkar");

personNames.add("Zaheer Khan");

personNames.add("Virat Kohli");

personNames.add("Anil Kumble");

personNames.add(12); // Compiler accepts it without any

issue

// size of the array list

int size = personNames.size();

// printing the ArrayList elements

for(int i = 0; i < size; i++)

System.out.println(personNames.get(i));

// for storing the length of strings

int len[] = new int[size];

// loop for finding the string length

for(int i = 0; i < size; i++)

{
 len[i] = ((String)personNames.get(i)).length();

}
Output:

Explanation:We observe thatthe program did not get terminated

normallybecause of the presence of number 12 in the list of strings. It raised
the ClassCastException. In order to avoid such exceptions, it is better to catch
such issues during the compile time. In fact, it is always better to address as
many issues as one can during compile-time. It is because compile-time issues
are much easier to handle as compared to runtime issues, such as exceptions.
To fix this issue during compile time, one has to use generics. The following
program shows the same.
FileName: GenericsExample6.java
// A Simple Java program to demonstrate that using

// generics,one can catch issues during the compile time

// importing ArrayList

import java.util.ArrayList;

public class GenericExample6

// main method

public static void main(String argvs[])

// Creating an ArrayList of type specified as String

ArrayList<String> personNames = new ArrayList<String>();

personNames.add("Rahul Dravid");

personNames.add("Virender Sehwag");

personNames.add("Sachin Tendulkar");

personNames.add("Zaheer Khan");
 personNames.add("Virat Kohli");

personNames.add("Anil Kumble");

personNames.add(12); // now, the compiler will not allow

// size of the array list

int size = personNames.size();

// printing the ArrayList elements

for(int i = 0; i < size; i++)

System.out.println(personNames.get(i));

// for storing the length of strings

int len[] = new int[size];

// loop for finding the string length

for(int i = 0; i < size; i++)

len[i] = ((String)personNames.get(i)).length();

}
Output:

Explanation:Now, we get the compilation error, as the compiler is not allowing

12 in the String array list, which is better as we do not have to wait for the last
loop to find the length of the string to get the exception. Also, the ArrayList is
ensuring type safety as it is not allowing the number 12 in its list. Thus, type
safety is also ensured.
2) In Generics, typecasting is not required: Generics allows us to specify the
parameter type. Therefore, only elements of that type are entertained in the list,
not the other one; hence typecasting is not required. In the absence of generics,
one has to do the type casting explicitly. Consider the following programs.
FileName: GenericsExample7.java
// A Simple Java program to demonstrate that type casting

// is required when generics is not used.

// importing ArrayList

import java.util.ArrayList;

public class GenericsExample7

// main method

public static void main(String argvs[])

// Creating an ArrayList that has not specified any type

ArrayList personNames = new ArrayList();

personNames.add("Rahul Dravid");

personNames.add("Virender Sehwag");

personNames.add("Sachin Tendulkar");

personNames.add("Zaheer Khan");

personNames.add("Virat Kohli");

personNames.add("Anil Kumble");

// size of the array list

int size = personNames.size();

// printing the ArrayList elements

for(int i = 0; i < size; i++)

// typecasting into string

String name = (String)personNames.get(i);

System.out.println(name);

}
 }

}
Output:
Rahul Dravid

Virender Sehwag

Sachin Tendulkar

Zaheer Khan

Virat Kohli

Anil Kumble
FileName: GenericsExample8.java
// A Simple Java program to demonstrate that type casting

// is not required when generics is used.

// importing ArrayList

import java.util.ArrayList;

public class GenericsExample8

// main method

public static void main(String argvs[])

// Creating an ArrayList that has not specified any type

ArrayList<String> personNames = new ArrayList<String>();

personNames.add("Rahul Dravid");

personNames.add("Virender Sehwag");

personNames.add("Sachin Tendulkar");

personNames.add("Zaheer Khan");

personNames.add("Virat Kohli");

personNames.add("Anil Kumble");
 // size of the array list

int size = personNames.size();

// printing the ArrayList elements

for(int i = 0; i < size; i++)

// type casting not required!

String name = personNames.get(i);

System.out.println(name);

}
Output:
Rahul Dravid

Virender Sehwag

Sachin Tendulkar

Zaheer Khan

Virat Kohli

Anil Kumble
3) Reusability of Code:By creating a generic class or method, one can use
different parameter types on the same generic method. Thus, writing code
explicitly for different types is not required. The topmost example of in this
section shows the same.