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.
