Generics means parameterized types. The idea is to allow type (Integer, String, … etc, and user-defined types) to be a parameter to methods, classes, and interfaces. Using Generics, it is possible to create classes that work with different data types.
An entity such as class, interface, or method that operates on a parameterized type is called generic entity.
Why Generics?
Object is the superclass of all other classes and Object reference can refer to any type object. These features lack type safety. Generics adds that type safety feature. We will discuss that type safety feature in later examples.
Generics in Java is similar to templates in C++. For example, classes like HashSet, ArrayList, HashMap, etc use generics very well. There are some fundamental differences between the two approaches to generic types.
Generic Class
Like C++, we use <> to specify parameter types in generic class creation. To create objects of generic class, we use following syntax.
// To create an instance of generic class
BaseType <Type> obj = new BaseType <Type>()
Note: In Parameter type we can not use primitives like
'int','char' or 'double'.// A Simple Java program to show working of user defined// Generic classes // We use < > to specify Parameter typeclass Test<T>{ // An object of type T is declared T obj; Test(T obj) { this.obj = obj; } // constructor public T getObject() { return this.obj; }} // Driver class to test aboveclass Main{ public static void main (String[] args) { // instance of Integer type Test <Integer> iObj = new Test<Integer>(15); System.out.println(iObj.getObject()); // instance of String type Test <String> sObj = new Test<String>("GeeksForGeeks"); System.out.println(sObj.getObject()); }} |
Output:
15 GeeksForGeeks
We can also pass multiple Type parameters in Generic classes.
// A Simple Java program to show multiple// type parameters in Java Generics // We use < > to specify Parameter typeclass Test<T, U>{ T obj1; // An object of type T U obj2; // An object of type U // constructor Test(T obj1, U obj2) { this.obj1 = obj1; this.obj2 = obj2; } // To print objects of T and U public void print() { System.out.println(obj1); System.out.println(obj2); }} // Driver class to test aboveclass Main{ public static void main (String[] args) { Test <String, Integer> obj = new Test<String, Integer>("GfG", 15); obj.print(); }} |
Output:
GfG 15
Generic Functions:
We can also write generic functions that can be called with different types of arguments based on the type of arguments passed to generic method, the compiler handles each method.
// A Simple Java program to show working of user defined// Generic functions class Test{ // A Generic method example static <T> void genericDisplay (T element) { System.out.println(element.getClass().getName() + " = " + element); } // Driver method public static void main(String[] args) { // Calling generic method with Integer argument genericDisplay(11); // Calling generic method with String argument genericDisplay("GeeksForGeeks"); // Calling generic method with double argument genericDisplay(1.0); }} |
Output :
java.lang.Integer = 11 java.lang.String = GeeksForGeeks java.lang.Double = 1.0
Generics work only with Reference Types:
When we declare an instance of generic type, the type argument passed to the type parameter must be a reference type. We cannot use primitive data types like int,char..,
Test<int> obj = new Test<int>(20); |
The above line results in a compile-time error, that can be resolved by using type wrappers to encapsulate a primitive type.
Generics Types Differ Based on Their Type Arguments:
Consider the following Java code.
// A Simple Java program to show working// of user-defined Generic classes // We use < > to specify Parameter typeclass Test<T>{ // An object of type T is declared T obj; Test(T obj) { this.obj = obj; } // constructor public T getObject() { return this.obj; }} // Driver class to test aboveclass Main{ public static void main (String[] args) { // instance of Integer type Test <Integer> iObj = new Test<Integer>(15); System.out.println(iObj.getObject()); // instance of String type Test <String> sObj = new Test<String>("GeeksForGeeks"); System.out.println(sObj.getObject()); iObj = sObj; //This results an error }} |
Output:
error: incompatible types: Test cannot be converted to Test
Even though iObj and sObj are of type Test, they are the references to different types because their type parameters differ. Generics add type safety through this and prevent errors.
Advantages of Generics:
Programs that uses Generics has got many benefits over non-generic code.
- Code Reuse: We can write a method/class/interface once and use for any type we want.
.
- Type Safety : Generics make errors to appear compile time than at run time (It’s always better to know problems in your code at compile time rather than making your code fail at run time). Suppose you want to create an ArrayList that store name of students and if by mistake programmer adds an integer object instead of string, compiler allows it. But, when we retrieve this data from ArrayList, it causes problems at runtime.
// A Simple Java program to demonstrate that NOT using// generics can cause run time exceptionsimportjava.util.*;classTest{publicstaticvoidmain(String[] args){// Creatinga an ArrayList without any type specifiedArrayList al =newArrayList();al.add("Sachin");al.add("Rahul");al.add(10);// Compiler allows thisString s1 = (String)al.get(0);String s2 = (String)al.get(1);// Causes Runtime ExceptionString s3 = (String)al.get(2);}}Output :
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String at Test.main(Test.java:19)How generics solve this problem?
At the time of defining ArrayList, we can specify that this list can take only String objects.// Using generics converts run time exceptions into// compile time exception.importjava.util.*;classTest{publicstaticvoidmain(String[] args){// Creating a an ArrayList with String specifiedArrayList <String> al =newArrayList<String> ();al.add("Sachin");al.add("Rahul");// Now Compiler doesn't allow thisal.add(10);String s1 = (String)al.get(0);String s2 = (String)al.get(1);String s3 = (String)al.get(2);}}Output:
15: error: no suitable method found for add(int) al.add(10); ^.
- Individual Type Casting is not needed: If we do not use generics, then, in the above example every-time we retrieve data from ArrayList, we have to typecast it. Typecasting at every retrieval operation is a big headache. If we already know that our list only holds string data then we need not to typecast it every time.
// We don't need to typecast individual members of ArrayListimportjava.util.*;classTest{publicstaticvoidmain(String[] args){// Creating a an ArrayList with String specifiedArrayList <String> al =newArrayList<String> ();al.add("Sachin");al.add("Rahul");// Typecasting is not neededString s1 = al.get(0);String s2 = al.get(1);}}.
- Generics promotes code reusability.
- Implementing generic algorithms: By using generics, we can implement algorithms that work on different types of objects and at the same they are type safe too.
References:
https://docs.oracle.com/javase/tutorial/java/generics/why.html
This article is contributed by Dharmesh Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.
